From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lyude Paul Subject: [RFC v2 2/4] drm/nouveau: Add support for BLCG on Kepler1 Date: Thu, 25 Jan 2018 22:35:04 -0500 Message-ID: <20180126033607.7682-3-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: Kate Stewart , David Airlie , Greg Kroah-Hartman , dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Alexandre Courbot , Ben Skeggs , Philippe Ombredanne , Thomas Gleixner List-Id: nouveau.vger.kernel.org VGhpcyBlbmFibGVzIEJMQ0cgb3B0aW1pemF0aW9uIGZvciBrZXBsZXIxLiBXaGVuIHVzaW5nIGNs b2NrZ2F0aW5nLApudmlkaWEncyBmaXJtd2FyZSBoYXMgYSBzZXQgb2YgcmVnaXN0ZXJzIHdoaWNo IGFyZSBpbml0aWFsbHkgcHJvZ3JhbW1lZApieSB0aGUgdmJpb3Mgd2l0aCB2YXJpb3VzIGVuZ2lu ZSBkZWxheXMgYW5kIG90aGVyIG15c3RlcmlvdXMgc2V0dGluZ3MKdGhhdCBhcmUgc2FmZSBlbm91 Z2ggdG8gYnJpbmcgdXAgdGhlIEdQVS4gSG93ZXZlciwgdGhlIHZhbHVlcyB1c2VkIGJ5CnRoZSB2 YmlvcyBhcmUgbW9yZSBwb3dlciBodW5ncnkgdGhlbiB0aGV5IG5lZWQgdG8gYmUsIHNvIHRoZSBu dmlkaWEgZHJpdmVyCndyaXRlcyBpdCdzIG93biBtb3JlIG9wdGltaXplZCBzZXQgb2YgQkxDRyBz ZXR0aW5ncyBiZWZvcmUgZW5hYmxpbmcKQ0dfQ1RSTC4gVGhpcyBhZGRzIHN1cHBvcnQgZm9yIHBy b2dyYW1taW5nIHRoZSBvcHRpbWl6ZWQgQkxDRyB2YWx1ZXMKZHVyaW5nIGVuZ2luZS9zdWJkZXYg aW5pdCwgd2hpY2ggZW5hYmxlcyByYXRoZXIgc2lnbmlmaWNhbnQgcG93ZXIKc2F2aW5ncy4KClRo aXMgaW50cm9kdWNlcyB0aGUgbnZrbV90aGVybV9jbGtnYXRlX2luaXQoKSBoZWxwZXIsIHdoaWNo IHdlIHVzZSB0bwpwcm9ncmFtIHRoZSBvcHRpbWl6ZWQgQkxDRyBzZXR0aW5ncyBiZWZvcmUgZW5h YmxpbmcgY2xvY2tnYXRpbmcgd2l0aApudmttX3RoZXJtX2Nsa2dhdGVfZW5hYmxlLgoKQXMgd2Vs bCwgdGhpcyBjb21taXQgc2hhcmVzIGEgbG90IG1vcmUgY29kZSB3aXRoIEZlcm1pIHNpbmNlIEJM Q0cgaXMKbW9zdGx5IHRoZSBzYW1lIHRoZXJlIGFzIGZhciBhcyB3ZSBjYW4gdGVsbC4gSW4gdGhl IGZ1dHVyZSwgaXQncyBsaWtlbHkKd2UnbGwgcmVmb3JtYXQgdGhlIGNsa2dhdGVfcGFja3MgZm9y IGtlcGxlcjEgc28gdGhhdCB0aGV5IHNoYXJlIGEgbGlzdApvZiBtbWlvIHBhY2tzIHdpdGggRmVy bWkuCgpTaWduZWQtb2ZmLWJ5OiBMeXVkZSBQYXVsIDxseXVkZUByZWRoYXQuY29tPgotLS0KIC4u Li9ncHUvZHJtL25vdXZlYXUvaW5jbHVkZS9udmttL3N1YmRldi90aGVybS5oICAgIHwgIDEyICsr CiBkcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmttL2VuZ2luZS9nci9nZjEwMC5oICAgICB8ICAg MSArCiBkcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmttL2VuZ2luZS9nci9nazEwNC5jICAgICB8 IDIwNyArKysrKysrKysrKysrKysrKysrKysKIGRyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20v ZW5naW5lL2dyL2drMTA0LmggICAgIHwgIDU1ICsrKysrKwogZHJpdmVycy9ncHUvZHJtL25vdXZl YXUvbnZrbS9zdWJkZXYvZmIvZ2YxMDAuYyAgICAgfCAgIDYgKwogZHJpdmVycy9ncHUvZHJtL25v dXZlYXUvbnZrbS9zdWJkZXYvZmIvZ2sxMDQuYyAgICAgfCAgNDcgKysrKysKIGRyaXZlcnMvZ3B1 L2RybS9ub3V2ZWF1L252a20vc3ViZGV2L2ZiL2drMTA0LmggICAgIHwgIDM1ICsrKysKIGRyaXZl cnMvZ3B1L2RybS9ub3V2ZWF1L252a20vc3ViZGV2L2ZiL3ByaXYuaCAgICAgIHwgICAyICsKIGRy aXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20vc3ViZGV2L3RoZXJtL0tidWlsZCAgIHwgICAxICsK IGRyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20vc3ViZGV2L3RoZXJtL2Jhc2UuYyAgIHwgIDEw ICsKIGRyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20vc3ViZGV2L3RoZXJtL2dmMTAwLmMgIHwg IDY3ICsrKysrKysKIGRyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20vc3ViZGV2L3RoZXJtL2dr MTA0LmMgIHwgICAxICsKIGRyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20vc3ViZGV2L3RoZXJt L2d0MjE1LmMgIHwgICAyICstCiBkcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmttL3N1YmRldi90 aGVybS9wcml2LmggICB8ICAgOCArCiAxNCBmaWxlcyBjaGFuZ2VkLCA0NTMgaW5zZXJ0aW9ucygr KSwgMSBkZWxldGlvbigtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS9ub3V2 ZWF1L252a20vZW5naW5lL2dyL2drMTA0LmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dw dS9kcm0vbm91dmVhdS9udmttL3N1YmRldi9mYi9nazEwNC5oCiBjcmVhdGUgbW9kZSAxMDA2NDQg ZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZrbS9zdWJkZXYvdGhlcm0vZ2YxMDAuYwoKZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L2luY2x1ZGUvbnZrbS9zdWJkZXYvdGhlcm0u aCBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L2luY2x1ZGUvbnZrbS9zdWJkZXYvdGhlcm0uaApp bmRleCAyNDBiMTliYjQ2NjcuLjkzOThkOWYwOTMzOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUv ZHJtL25vdXZlYXUvaW5jbHVkZS9udmttL3N1YmRldi90aGVybS5oCisrKyBiL2RyaXZlcnMvZ3B1 L2RybS9ub3V2ZWF1L2luY2x1ZGUvbnZrbS9zdWJkZXYvdGhlcm0uaApAQCAtNDYsNiArNDYsMTYg QEAgZW51bSBudmttX3RoZXJtX2F0dHJfdHlwZSB7CiAJTlZLTV9USEVSTV9BVFRSX1RIUlNfU0hV VERPV05fSFlTVCA9IDE3LAogfTsKIAorc3RydWN0IG52a21fdGhlcm1fY2xrZ2F0ZV9pbml0IHsK Kwl1MzIgYWRkcjsKKwl1OCAgY291bnQ7CisJdTMyIGRhdGE7Cit9OworCitzdHJ1Y3QgbnZrbV90 aGVybV9jbGtnYXRlX3BhY2sgeworCWNvbnN0IHN0cnVjdCBudmttX3RoZXJtX2Nsa2dhdGVfaW5p dCAqaW5pdDsKK307CisKIHN0cnVjdCBudmttX3RoZXJtIHsKIAljb25zdCBzdHJ1Y3QgbnZrbV90 aGVybV9mdW5jICpmdW5jOwogCXN0cnVjdCBudmttX3N1YmRldiBzdWJkZXY7CkBAIC05Miw2ICsx MDIsOCBAQCBzdHJ1Y3QgbnZrbV90aGVybSB7CiBpbnQgbnZrbV90aGVybV90ZW1wX2dldChzdHJ1 Y3QgbnZrbV90aGVybSAqKTsKIGludCBudmttX3RoZXJtX2Zhbl9zZW5zZShzdHJ1Y3QgbnZrbV90 aGVybSAqKTsKIGludCBudmttX3RoZXJtX2NzdGF0ZShzdHJ1Y3QgbnZrbV90aGVybSAqLCBpbnQs IGludCk7Cit2b2lkIG52a21fdGhlcm1fY2xrZ2F0ZV9pbml0KHN0cnVjdCBudmttX3RoZXJtICos CisJCQkgICAgIGNvbnN0IHN0cnVjdCBudmttX3RoZXJtX2Nsa2dhdGVfcGFjayAqKTsKIHZvaWQg bnZrbV90aGVybV9jbGtnYXRlX2VuYWJsZShzdHJ1Y3QgbnZrbV90aGVybSAqKTsKIHZvaWQgbnZr bV90aGVybV9jbGtnYXRlX2Zpbmkoc3RydWN0IG52a21fdGhlcm0gKiwgYm9vbCk7CiAKZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20vZW5naW5lL2dyL2dmMTAwLmggYi9k cml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmttL2VuZ2luZS9nci9nZjEwMC5oCmluZGV4IGQ3YzJh ZGI5YjU0My4uYzhlYzNmZDk3MTU1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVh dS9udmttL2VuZ2luZS9nci9nZjEwMC5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252 a20vZW5naW5lL2dyL2dmMTAwLmgKQEAgLTEzNyw2ICsxMzcsNyBAQCBzdHJ1Y3QgZ2YxMDBfZ3Jf ZnVuYyB7CiAJaW50ICgqcm9wcykoc3RydWN0IGdmMTAwX2dyICopOwogCWludCBwcGNfbnI7CiAJ Y29uc3Qgc3RydWN0IGdmMTAwX2dyY3R4X2Z1bmMgKmdyY3R4OworCWNvbnN0IHN0cnVjdCBudmtt X3RoZXJtX2Nsa2dhdGVfcGFjayAqY2xrZ2F0ZV9wYWNrOwogCXN0cnVjdCBudmttX3NjbGFzcyBz Y2xhc3NbXTsKIH07CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20v ZW5naW5lL2dyL2drMTA0LmMgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmttL2VuZ2luZS9n ci9nazEwNC5jCmluZGV4IDVlODJmOTRjMjI0NS4uMTdjZWE5YzcwZjdmIDEwMDY0NAotLS0gYS9k cml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmttL2VuZ2luZS9nci9nazEwNC5jCisrKyBiL2RyaXZl cnMvZ3B1L2RybS9ub3V2ZWF1L252a20vZW5naW5lL2dyL2drMTA0LmMKQEAgLTIyLDYgKzIyLDcg QEAKICAqIEF1dGhvcnM6IEJlbiBTa2VnZ3MgPGJza2VnZ3NAcmVkaGF0LmNvbT4KICAqLwogI2lu Y2x1ZGUgImdmMTAwLmgiCisjaW5jbHVkZSAiZ2sxMDQuaCIKICNpbmNsdWRlICJjdHhnZjEwMC5o IgogCiAjaW5jbHVkZSA8bnZpZi9jbGFzcy5oPgpAQCAtMTczLDYgKzE3NCwyMDggQEAgZ2sxMDRf Z3JfcGFja19tbWlvW10gPSB7CiAJe30KIH07CiAKK2NvbnN0IHN0cnVjdCBudmttX3RoZXJtX2Ns a2dhdGVfaW5pdAorZ2sxMDRfY2xrZ2F0ZV9ibGNnX2luaXRfbWFpbl8wW10gPSB7CisJeyAweDQw NDFmMCwgMSwgMHgwMDAwNDA0NiB9LAorCXsgMHg0MDk4OTAsIDEsIDB4MDAwMDAwNDUgfSwKKwl7 IDB4NDA5OGIwLCAxLCAweDAwMDAwMDdmIH0sCisJe30KK307CisKK2NvbnN0IHN0cnVjdCBudmtt X3RoZXJtX2Nsa2dhdGVfaW5pdAorZ2sxMDRfY2xrZ2F0ZV9ibGNnX2luaXRfcnN0cjJkXzBbXSA9 IHsKKwl7IDB4NDA3OGMwLCAxLCAweDAwMDAwMDQyIH0sCisJe30KK307CisKK2NvbnN0IHN0cnVj dCBudmttX3RoZXJtX2Nsa2dhdGVfaW5pdAorZ2sxMDRfY2xrZ2F0ZV9ibGNnX2luaXRfdW5rXzBb XSA9IHsKKwl7IDB4NDA2MDAwLCAxLCAweDAwMDA0MDQ0IH0sCisJeyAweDQwNTg2MCwgMSwgMHgw MDAwNDA0MiB9LAorCXsgMHg0MDU5MGMsIDEsIDB4MDAwMDQwNDIgfSwKKwl7fQorfTsKKworY29u c3Qgc3RydWN0IG52a21fdGhlcm1fY2xrZ2F0ZV9pbml0CitnazEwNF9jbGtnYXRlX2JsY2dfaW5p dF9nY2NfMFtdID0geworCXsgMHg0MDgwNDAsIDEsIDB4MDAwMDQwNDQgfSwKKwl7fQorfTsKKwor Y29uc3Qgc3RydWN0IG52a21fdGhlcm1fY2xrZ2F0ZV9pbml0CitnazEwNF9jbGtnYXRlX2JsY2df aW5pdF9za2VkXzBbXSA9IHsKKwl7IDB4NDA3MDAwLCAxLCAweDAwMDA0MDQ0IH0sCisJe30KK307 CisKK2NvbnN0IHN0cnVjdCBudmttX3RoZXJtX2Nsa2dhdGVfaW5pdAorZ2sxMDRfY2xrZ2F0ZV9i bGNnX2luaXRfdW5rXzFbXSA9IHsKKwl7IDB4NDA1YmYwLCAxLCAweDAwMDA0MDQ0IH0sCisJe30K K307CisKK2NvbnN0IHN0cnVjdCBudmttX3RoZXJtX2Nsa2dhdGVfaW5pdAorZ2sxMDRfY2xrZ2F0 ZV9ibGNnX2luaXRfZ3BjX2N0eGN0bF8wW10gPSB7CisJeyAweDQxYTg5MCwgMSwgMHgwMDAwMDA0 MiB9LAorCXsgMHg0MWE4YjAsIDEsIDB4MDAwMDAwN2YgfSwKKwl7fQorfTsKKworY29uc3Qgc3Ry dWN0IG52a21fdGhlcm1fY2xrZ2F0ZV9pbml0CitnazEwNF9jbGtnYXRlX2JsY2dfaW5pdF9ncGNf dW5rXzBbXSA9IHsKKwl7IDB4NDE4NTAwLCAxLCAweDAwMDA0MDQyIH0sCisJeyAweDQxODYwOCwg MSwgMHgwMDAwNDA0MiB9LAorCXsgMHg0MTg2ODgsIDEsIDB4MDAwMDQwNDIgfSwKKwl7IDB4NDE4 NzE4LCAxLCAweDAwMDAwMDQyIH0sCisJe30KK307CisKK2NvbnN0IHN0cnVjdCBudmttX3RoZXJt X2Nsa2dhdGVfaW5pdAorZ2sxMDRfY2xrZ2F0ZV9ibGNnX2luaXRfZ3BjX2VzZXR1cF8wW10gPSB7 CisJeyAweDQxODgyOCwgMSwgMHgwMDAwMDA0NCB9LAorCXt9Cit9OworCitjb25zdCBzdHJ1Y3Qg bnZrbV90aGVybV9jbGtnYXRlX2luaXQKK2drMTA0X2Nsa2dhdGVfYmxjZ19pbml0X2dwY190cGJ1 c18wW10gPSB7CisJeyAweDQxOGJiYywgMSwgMHgwMDAwNDA0MiB9LAorCXt9Cit9OworCitjb25z dCBzdHJ1Y3QgbnZrbV90aGVybV9jbGtnYXRlX2luaXQKK2drMTA0X2Nsa2dhdGVfYmxjZ19pbml0 X2dwY196Y3VsbF8wW10gPSB7CisJeyAweDQxODk3MCwgMSwgMHgwMDAwNDA0MiB9LAorCXt9Cit9 OworCitjb25zdCBzdHJ1Y3QgbnZrbV90aGVybV9jbGtnYXRlX2luaXQKK2drMTA0X2Nsa2dhdGVf YmxjZ19pbml0X2dwY190cGNvbmZfMFtdID0geworCXsgMHg0MThjNzAsIDEsIDB4MDAwMDQwNDIg fSwKKwl7fQorfTsKKworY29uc3Qgc3RydWN0IG52a21fdGhlcm1fY2xrZ2F0ZV9pbml0CitnazEw NF9jbGtnYXRlX2JsY2dfaW5pdF9ncGNfdW5rXzFbXSA9IHsKKwl7IDB4NDE4Y2YwLCAxLCAweDAw MDA0MDQyIH0sCisJeyAweDQxOGQ3MCwgMSwgMHgwMDAwNDA0MiB9LAorCXsgMHg0MThmMGMsIDEs IDB4MDAwMDQwNDIgfSwKKwl7IDB4NDE4ZTBjLCAxLCAweDAwMDA0MDQyIH0sCisJe30KK307CisK K2NvbnN0IHN0cnVjdCBudmttX3RoZXJtX2Nsa2dhdGVfaW5pdAorZ2sxMDRfY2xrZ2F0ZV9ibGNn X2luaXRfZ3BjX2djY18wW10gPSB7CisJeyAweDQxOTAyMCwgMSwgMHgwMDAwNDA0MiB9LAorCXsg MHg0MTkwMzgsIDEsIDB4MDAwMDAwNDIgfSwKKwl7fQorfTsKKworY29uc3Qgc3RydWN0IG52a21f dGhlcm1fY2xrZ2F0ZV9pbml0CitnazEwNF9jbGtnYXRlX2JsY2dfaW5pdF9ncGNfZmZiXzBbXSA9 IHsKKwl7IDB4NDE4ODk4LCAxLCAweDAwMDAwMDQyIH0sCisJe30KK307CisKK2NvbnN0IHN0cnVj dCBudmttX3RoZXJtX2Nsa2dhdGVfaW5pdAorZ2sxMDRfY2xrZ2F0ZV9ibGNnX2luaXRfZ3BjX3Rl eF8wW10gPSB7CisJeyAweDQxOWE0MCwgOSwgMHgwMDAwNDA0MiB9LAorCXsgMHg0MTlhY2MsIDEs IDB4MDAwMDQwNDcgfSwKKwl7fQorfTsKKworY29uc3Qgc3RydWN0IG52a21fdGhlcm1fY2xrZ2F0 ZV9pbml0CitnazEwNF9jbGtnYXRlX2JsY2dfaW5pdF9ncGNfcG9seV8wW10gPSB7CisJeyAweDQx OTg2OCwgMSwgMHgwMDAwMDA0MiB9LAorCXt9Cit9OworCitjb25zdCBzdHJ1Y3QgbnZrbV90aGVy bV9jbGtnYXRlX2luaXQKK2drMTA0X2Nsa2dhdGVfYmxjZ19pbml0X2dwY19sMWNfMFtdID0gewor CXsgMHg0MTljY2MsIDMsIDB4MDAwMDAwNDIgfSwKKwl7fQorfTsKKworY29uc3Qgc3RydWN0IG52 a21fdGhlcm1fY2xrZ2F0ZV9pbml0CitnazEwNF9jbGtnYXRlX2JsY2dfaW5pdF9ncGNfdW5rXzJb XSA9IHsKKwl7IDB4NDE5YzcwLCAxLCAweDAwMDA0MDQ1IH0sCisJe30KK307CisKK2NvbnN0IHN0 cnVjdCBudmttX3RoZXJtX2Nsa2dhdGVfaW5pdAorZ2sxMDRfY2xrZ2F0ZV9ibGNnX2luaXRfZ3Bj X21wXzBbXSA9IHsKKwl7IDB4NDE5ZmQwLCAxLCAweDAwMDA0MDQzIH0sCisJeyAweDQxOWZkOCwg MSwgMHgwMDAwNDA0OSB9LAorCXsgMHg0MTlmZTAsIDIsIDB4MDAwMDQwNDIgfSwKKwl7IDB4NDE5 ZmYwLCAxLCAweDAwMDA0MDQ2IH0sCisJeyAweDQxOWZmOCwgMSwgMHgwMDAwNDA0MiB9LAorCXt9 Cit9OworCitjb25zdCBzdHJ1Y3QgbnZrbV90aGVybV9jbGtnYXRlX2luaXQKK2drMTA0X2Nsa2dh dGVfYmxjZ19pbml0X2dwY19wcGNfMFtdID0geworCXsgMHg0MWJlMjgsIDEsIDB4MDAwMDAwNDIg fSwKKwl7IDB4NDFiZmU4LCAxLCAweDAwMDA0MDQyIH0sCisJeyAweDQxYmVkMCwgMSwgMHgwMDAw NDA0MiB9LAorCXt9Cit9OworCitjb25zdCBzdHJ1Y3QgbnZrbV90aGVybV9jbGtnYXRlX2luaXQK K2drMTA0X2Nsa2dhdGVfYmxjZ19pbml0X3JvcF96cm9wXzBbXSA9IHsKKwl7IDB4NDA4ODEwLCAy LCAweDAwMDA0MDQyIH0sCisJe30KK307CisKK2NvbnN0IHN0cnVjdCBudmttX3RoZXJtX2Nsa2dh dGVfaW5pdAorZ2sxMDRfY2xrZ2F0ZV9ibGNnX2luaXRfcm9wXzBbXSA9IHsKKwl7IDB4NDA4YTgw LCA2LCAweDAwMDA0MDQyIH0sCisJe30KK307CisKK2NvbnN0IHN0cnVjdCBudmttX3RoZXJtX2Ns a2dhdGVfaW5pdAorZ2sxMDRfY2xrZ2F0ZV9ibGNnX2luaXRfcm9wX2Nyb3BfMFtdID0geworCXsg MHg0MDg5YTgsIDEsIDB4MDAwMDQwNDIgfSwKKwl7IDB4NDA4OWIwLCAxLCAweDAwMDAwMDQyIH0s CisJeyAweDQwODliOCwgMSwgMHgwMDAwNDA0MiB9LAorCXt9Cit9OworCitjb25zdCBzdHJ1Y3Qg bnZrbV90aGVybV9jbGtnYXRlX2luaXQKK2drMTA0X2Nsa2dhdGVfYmxjZ19pbml0X3B4YmFyXzBb XSA9IHsKKwl7IDB4MTNjODIwLCAxLCAweDAwMDEwMDdmIH0sCisJeyAweDEzY2JlMCwgMSwgMHgw MDAwMDA0MiB9LAorCXt9Cit9OworCitjb25zdCBzdHJ1Y3QgbnZrbV90aGVybV9jbGtnYXRlX3Bh Y2sKK2drMTA0X2Nsa2dhdGVfcGFja1tdID0geworCXsgZ2sxMDRfY2xrZ2F0ZV9ibGNnX2luaXRf bWFpbl8wIH0sCisJeyBnazEwNF9jbGtnYXRlX2JsY2dfaW5pdF9yc3RyMmRfMCB9LAorCXsgZ2sx MDRfY2xrZ2F0ZV9ibGNnX2luaXRfdW5rXzAgfSwKKwl7IGdrMTA0X2Nsa2dhdGVfYmxjZ19pbml0 X2djY18wIH0sCisJeyBnazEwNF9jbGtnYXRlX2JsY2dfaW5pdF9za2VkXzAgfSwKKwl7IGdrMTA0 X2Nsa2dhdGVfYmxjZ19pbml0X3Vua18xIH0sCisJeyBnazEwNF9jbGtnYXRlX2JsY2dfaW5pdF9n cGNfY3R4Y3RsXzAgfSwKKwl7IGdrMTA0X2Nsa2dhdGVfYmxjZ19pbml0X2dwY191bmtfMCB9LAor CXsgZ2sxMDRfY2xrZ2F0ZV9ibGNnX2luaXRfZ3BjX2VzZXR1cF8wIH0sCisJeyBnazEwNF9jbGtn YXRlX2JsY2dfaW5pdF9ncGNfdHBidXNfMCB9LAorCXsgZ2sxMDRfY2xrZ2F0ZV9ibGNnX2luaXRf Z3BjX3pjdWxsXzAgfSwKKwl7IGdrMTA0X2Nsa2dhdGVfYmxjZ19pbml0X2dwY190cGNvbmZfMCB9 LAorCXsgZ2sxMDRfY2xrZ2F0ZV9ibGNnX2luaXRfZ3BjX3Vua18xIH0sCisJeyBnazEwNF9jbGtn YXRlX2JsY2dfaW5pdF9ncGNfZ2NjXzAgfSwKKwl7IGdrMTA0X2Nsa2dhdGVfYmxjZ19pbml0X2dw Y19mZmJfMCB9LAorCXsgZ2sxMDRfY2xrZ2F0ZV9ibGNnX2luaXRfZ3BjX3RleF8wIH0sCisJeyBn azEwNF9jbGtnYXRlX2JsY2dfaW5pdF9ncGNfcG9seV8wIH0sCisJeyBnazEwNF9jbGtnYXRlX2Js Y2dfaW5pdF9ncGNfbDFjXzAgfSwKKwl7IGdrMTA0X2Nsa2dhdGVfYmxjZ19pbml0X2dwY191bmtf MiB9LAorCXsgZ2sxMDRfY2xrZ2F0ZV9ibGNnX2luaXRfZ3BjX21wXzAgfSwKKwl7IGdrMTA0X2Ns a2dhdGVfYmxjZ19pbml0X2dwY19wcGNfMCB9LAorCXsgZ2sxMDRfY2xrZ2F0ZV9ibGNnX2luaXRf cm9wX3pyb3BfMCB9LAorCXsgZ2sxMDRfY2xrZ2F0ZV9ibGNnX2luaXRfcm9wXzAgfSwKKwl7IGdr MTA0X2Nsa2dhdGVfYmxjZ19pbml0X3JvcF9jcm9wXzAgfSwKKwl7IGdrMTA0X2Nsa2dhdGVfYmxj Z19pbml0X3B4YmFyXzAgfSwKKwl7fQorfTsKKwogLyoqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAq IFBHUkFQSCBlbmdpbmUvc3ViZGV2IGZ1bmN0aW9ucwogICoqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8K QEAgLTIxNCw2ICs0MTcsOSBAQCBnazEwNF9ncl9pbml0KHN0cnVjdCBnZjEwMF9nciAqZ3IpCiAJ Z3ItPmZ1bmMtPmluaXRfZ3BjX21tdShncik7CiAKIAlnZjEwMF9ncl9tbWlvKGdyLCBnci0+ZnVu Yy0+bW1pbyk7CisJaWYgKGdyLT5mdW5jLT5jbGtnYXRlX3BhY2spCisJCW52a21fdGhlcm1fY2xr Z2F0ZV9pbml0KGdyLT5iYXNlLmVuZ2luZS5zdWJkZXYuZGV2aWNlLT50aGVybSwKKwkJCQkJZ3It PmZ1bmMtPmNsa2dhdGVfcGFjayk7CiAKIAludmttX3dyMzIoZGV2aWNlLCBHUENfVU5JVCgwLCAw eDMwMTgpLCAweDAwMDAwMDAxKTsKIApAQCAtMzM4LDYgKzU0NCw3IEBAIGdrMTA0X2dyID0gewog CS5yb3BzID0gZ2YxMDBfZ3Jfcm9wcywKIAkucHBjX25yID0gMSwKIAkuZ3JjdHggPSAmZ2sxMDRf Z3JjdHgsCisJLmNsa2dhdGVfcGFjayA9IGdrMTA0X2Nsa2dhdGVfcGFjaywKIAkuc2NsYXNzID0g ewogCQl7IC0xLCAtMSwgRkVSTUlfVFdPRF9BIH0sCiAJCXsgLTEsIC0xLCBLRVBMRVJfSU5MSU5F X1RPX01FTU9SWV9BIH0sCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmtt L2VuZ2luZS9nci9nazEwNC5oIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZrbS9lbmdpbmUv Z3IvZ2sxMDQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmEyNGMx NzczNjVkMQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20v ZW5naW5lL2dyL2drMTA0LmgKQEAgLTAsMCArMSw1NSBAQAorLyoKKyAqIENvcHlyaWdodCAyMDE4 IFJlZCBIYXQgSW5jLgorICoKKyAqIFBlcm1pc3Npb24gaXMgaGVyZWJ5IGdyYW50ZWQsIGZyZWUg b2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmluZyBhCisgKiBjb3B5IG9mIHRoaXMgc29m dHdhcmUgYW5kIGFzc29jaWF0ZWQgZG9jdW1lbnRhdGlvbiBmaWxlcyAodGhlICJTb2Z0d2FyZSIp LAorICogdG8gZGVhbCBpbiB0aGUgU29mdHdhcmUgd2l0aG91dCByZXN0cmljdGlvbiwgaW5jbHVk aW5nIHdpdGhvdXQgbGltaXRhdGlvbgorICogdGhlIHJpZ2h0cyB0byB1c2UsIGNvcHksIG1vZGlm eSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1YmxpY2Vuc2UsCisgKiBhbmQvb3Igc2Vs bCBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8gcGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0 aGUKKyAqIFNvZnR3YXJlIGlzIGZ1cm5pc2hlZCB0byBkbyBzbywgc3ViamVjdCB0byB0aGUgZm9s bG93aW5nIGNvbmRpdGlvbnM6CisgKgorICogVGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UgYW5k IHRoaXMgcGVybWlzc2lvbiBub3RpY2Ugc2hhbGwgYmUgaW5jbHVkZWQgaW4KKyAqIGFsbCBjb3Bp ZXMgb3Igc3Vic3RhbnRpYWwgcG9ydGlvbnMgb2YgdGhlIFNvZnR3YXJlLgorICoKKyAqIFRIRSBT T0ZUV0FSRSBJUyBQUk9WSURFRCAiQVMgSVMiLCBXSVRIT1VUIFdBUlJBTlRZIE9GIEFOWSBLSU5E LCBFWFBSRVNTIE9SCisgKiBJTVBMSUVELCBJTkNMVURJTkcgQlVUIE5PVCBMSU1JVEVEIFRPIFRI RSBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSwKKyAqIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUiBQVVJQT1NFIEFORCBOT05JTkZSSU5HRU1FTlQuICBJTiBOTyBFVkVOVCBTSEFMTAorICog VEhFIENPUFlSSUdIVCBIT0xERVIoUykgT1IgQVVUSE9SKFMpIEJFIExJQUJMRSBGT1IgQU5ZIENM QUlNLCBEQU1BR0VTIE9SCisgKiBPVEhFUiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9O IE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSwKKyAqIEFSSVNJTkcgRlJPTSwgT1VUIE9G IE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUgorICogT1RI RVIgREVBTElOR1MgSU4gVEhFIFNPRlRXQVJFLgorICoKKyAqIEF1dGhvcnM6IEx5dWRlIFBhdWwg PGx5dWRlQHJlZGhhdC5jb20+CisgKi8KKyNpZm5kZWYgX19HSzEwNF9HUl9IX18KKyNkZWZpbmUg X19HSzEwNF9HUl9IX18KKworI2luY2x1ZGUgPHN1YmRldi90aGVybS5oPgorCitleHRlcm4gY29u c3Qgc3RydWN0IG52a21fdGhlcm1fY2xrZ2F0ZV9pbml0IGdrMTA0X2Nsa2dhdGVfYmxjZ19pbml0 X21haW5fMFtdOworZXh0ZXJuIGNvbnN0IHN0cnVjdCBudmttX3RoZXJtX2Nsa2dhdGVfaW5pdCBn azEwNF9jbGtnYXRlX2JsY2dfaW5pdF9yc3RyMmRfMFtdOworZXh0ZXJuIGNvbnN0IHN0cnVjdCBu dmttX3RoZXJtX2Nsa2dhdGVfaW5pdCBnazEwNF9jbGtnYXRlX2JsY2dfaW5pdF91bmtfMFtdOwor ZXh0ZXJuIGNvbnN0IHN0cnVjdCBudmttX3RoZXJtX2Nsa2dhdGVfaW5pdCBnazEwNF9jbGtnYXRl X2JsY2dfaW5pdF9nY2NfMFtdOworZXh0ZXJuIGNvbnN0IHN0cnVjdCBudmttX3RoZXJtX2Nsa2dh dGVfaW5pdCBnazEwNF9jbGtnYXRlX2JsY2dfaW5pdF9za2VkXzBbXTsKK2V4dGVybiBjb25zdCBz dHJ1Y3QgbnZrbV90aGVybV9jbGtnYXRlX2luaXQgZ2sxMDRfY2xrZ2F0ZV9ibGNnX2luaXRfdW5r XzFbXTsKK2V4dGVybiBjb25zdCBzdHJ1Y3QgbnZrbV90aGVybV9jbGtnYXRlX2luaXQgZ2sxMDRf Y2xrZ2F0ZV9ibGNnX2luaXRfZ3BjX2N0eGN0bF8wW107CitleHRlcm4gY29uc3Qgc3RydWN0IG52 a21fdGhlcm1fY2xrZ2F0ZV9pbml0IGdrMTA0X2Nsa2dhdGVfYmxjZ19pbml0X2dwY191bmtfMFtd OworZXh0ZXJuIGNvbnN0IHN0cnVjdCBudmttX3RoZXJtX2Nsa2dhdGVfaW5pdCBnazEwNF9jbGtn YXRlX2JsY2dfaW5pdF9ncGNfZXNldHVwXzBbXTsKK2V4dGVybiBjb25zdCBzdHJ1Y3QgbnZrbV90 aGVybV9jbGtnYXRlX2luaXQgZ2sxMDRfY2xrZ2F0ZV9ibGNnX2luaXRfZ3BjX3RwYnVzXzBbXTsK K2V4dGVybiBjb25zdCBzdHJ1Y3QgbnZrbV90aGVybV9jbGtnYXRlX2luaXQgZ2sxMDRfY2xrZ2F0 ZV9ibGNnX2luaXRfZ3BjX3pjdWxsXzBbXTsKK2V4dGVybiBjb25zdCBzdHJ1Y3QgbnZrbV90aGVy bV9jbGtnYXRlX2luaXQgZ2sxMDRfY2xrZ2F0ZV9ibGNnX2luaXRfZ3BjX3RwY29uZl8wW107Citl eHRlcm4gY29uc3Qgc3RydWN0IG52a21fdGhlcm1fY2xrZ2F0ZV9pbml0IGdrMTA0X2Nsa2dhdGVf YmxjZ19pbml0X2dwY191bmtfMVtdOworZXh0ZXJuIGNvbnN0IHN0cnVjdCBudmttX3RoZXJtX2Ns a2dhdGVfaW5pdCBnazEwNF9jbGtnYXRlX2JsY2dfaW5pdF9ncGNfZ2NjXzBbXTsKK2V4dGVybiBj b25zdCBzdHJ1Y3QgbnZrbV90aGVybV9jbGtnYXRlX2luaXQgZ2sxMDRfY2xrZ2F0ZV9ibGNnX2lu aXRfZ3BjX2ZmYl8wW107CitleHRlcm4gY29uc3Qgc3RydWN0IG52a21fdGhlcm1fY2xrZ2F0ZV9p bml0IGdrMTA0X2Nsa2dhdGVfYmxjZ19pbml0X2dwY190ZXhfMFtdOworZXh0ZXJuIGNvbnN0IHN0 cnVjdCBudmttX3RoZXJtX2Nsa2dhdGVfaW5pdCBnazEwNF9jbGtnYXRlX2JsY2dfaW5pdF9ncGNf cG9seV8wW107CitleHRlcm4gY29uc3Qgc3RydWN0IG52a21fdGhlcm1fY2xrZ2F0ZV9pbml0IGdr MTA0X2Nsa2dhdGVfYmxjZ19pbml0X2dwY19sMWNfMFtdOworZXh0ZXJuIGNvbnN0IHN0cnVjdCBu dmttX3RoZXJtX2Nsa2dhdGVfaW5pdCBnazEwNF9jbGtnYXRlX2JsY2dfaW5pdF9ncGNfdW5rXzJb XTsKK2V4dGVybiBjb25zdCBzdHJ1Y3QgbnZrbV90aGVybV9jbGtnYXRlX2luaXQgZ2sxMDRfY2xr Z2F0ZV9ibGNnX2luaXRfZ3BjX21wXzBbXTsKK2V4dGVybiBjb25zdCBzdHJ1Y3QgbnZrbV90aGVy bV9jbGtnYXRlX2luaXQgZ2sxMDRfY2xrZ2F0ZV9ibGNnX2luaXRfZ3BjX3BwY18wW107CitleHRl cm4gY29uc3Qgc3RydWN0IG52a21fdGhlcm1fY2xrZ2F0ZV9pbml0IGdrMTA0X2Nsa2dhdGVfYmxj Z19pbml0X3JvcF96cm9wXzBbXTsKK2V4dGVybiBjb25zdCBzdHJ1Y3QgbnZrbV90aGVybV9jbGtn YXRlX2luaXQgZ2sxMDRfY2xrZ2F0ZV9ibGNnX2luaXRfcm9wXzBbXTsKK2V4dGVybiBjb25zdCBz dHJ1Y3QgbnZrbV90aGVybV9jbGtnYXRlX2luaXQgZ2sxMDRfY2xrZ2F0ZV9ibGNnX2luaXRfcm9w X2Nyb3BfMFtdOworZXh0ZXJuIGNvbnN0IHN0cnVjdCBudmttX3RoZXJtX2Nsa2dhdGVfaW5pdCBn azEwNF9jbGtnYXRlX2JsY2dfaW5pdF9weGJhcl8wW107CisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZrbS9zdWJkZXYvZmIvZ2YxMDAuYyBiL2RyaXZlcnMv Z3B1L2RybS9ub3V2ZWF1L252a20vc3ViZGV2L2ZiL2dmMTAwLmMKaW5kZXggNDdkMjhjMjc5NzA3 Li5jZGM0ZTBhMmNjNmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20v c3ViZGV2L2ZiL2dmMTAwLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZrbS9zdWJk ZXYvZmIvZ2YxMDAuYwpAQCAtMjYsNiArMjYsNyBAQAogCiAjaW5jbHVkZSA8Y29yZS9tZW1vcnku aD4KICNpbmNsdWRlIDxjb3JlL29wdGlvbi5oPgorI2luY2x1ZGUgPHN1YmRldi90aGVybS5oPgog CiB2b2lkCiBnZjEwMF9mYl9pbnRyKHN0cnVjdCBudmttX2ZiICpiYXNlKQpAQCAtOTIsNiArOTMs MTEgQEAgZ2YxMDBfZmJfaW5pdChzdHJ1Y3QgbnZrbV9mYiAqYmFzZSkKIAogCWlmIChmYi0+cjEw MGMxMF9wYWdlKQogCQludmttX3dyMzIoZGV2aWNlLCAweDEwMGMxMCwgZmItPnIxMDBjMTAgPj4g OCk7CisKKwlpZiAoYmFzZS0+ZnVuYy0+Y2xrZ2F0ZV9wYWNrKSB7CisJCW52a21fdGhlcm1fY2xr Z2F0ZV9pbml0KGRldmljZS0+dGhlcm0sCisJCQkJCWJhc2UtPmZ1bmMtPmNsa2dhdGVfcGFjayk7 CisJfQogfQogCiB2b2lkICoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252 a20vc3ViZGV2L2ZiL2drMTA0LmMgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmttL3N1YmRl di9mYi9nazEwNC5jCmluZGV4IDBhNmU4ZWFhZDQyYy4uNDhmZDk4ZTA4YmFhIDEwMDY0NAotLS0g YS9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmttL3N1YmRldi9mYi9nazEwNC5jCisrKyBiL2Ry aXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20vc3ViZGV2L2ZiL2drMTA0LmMKQEAgLTIwLDEwICsy MCw1NiBAQAogICogT1RIRVIgREVBTElOR1MgSU4gVEhFIFNPRlRXQVJFLgogICoKICAqIEF1dGhv cnM6IEJlbiBTa2VnZ3MKKyAqICAgICAgICAgIEx5dWRlIFBhdWwKICAqLworI2luY2x1ZGUgImdr MTA0LmgiCiAjaW5jbHVkZSAiZ2YxMDAuaCIKICNpbmNsdWRlICJyYW0uaCIKIAorLyoKKyAqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqCisgKiBQR1JBUEggcmVnaXN0ZXJzIGZvciBjbG9ja2dhdGluZwor ICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioKKyAqLworY29uc3Qgc3RydWN0IG52a21fdGhlcm1fY2xr Z2F0ZV9pbml0CitnazEwNF9mYl9jbGtnYXRlX2JsY2dfaW5pdF91bmtfMFtdID0geworCXsgMHgx MDBkMTAsIDEsIDB4MDAwMGMyNDQgfSwKKwl7IDB4MTAwZDMwLCAxLCAweDAwMDBjMjQyIH0sCisJ eyAweDEwMGQzYywgMSwgMHgwMDAwMDI0MiB9LAorCXsgMHgxMDBkNDgsIDEsIDB4MDAwMDAyNDIg fSwKKwl7IDB4MTAwZDFjLCAxLCAweDAwMDAwMDQyIH0sCisJe30KK307CisKK2NvbnN0IHN0cnVj dCBudmttX3RoZXJtX2Nsa2dhdGVfaW5pdAorZ2sxMDRfZmJfY2xrZ2F0ZV9ibGNnX2luaXRfdm1f MFtdID0geworCXsgMHgxMDBjOTgsIDEsIDB4MDAwMDAyNDIgfSwKKwl7fQorfTsKKworY29uc3Qg c3RydWN0IG52a21fdGhlcm1fY2xrZ2F0ZV9pbml0CitnazEwNF9mYl9jbGtnYXRlX2JsY2dfaW5p dF9tYWluXzBbXSA9IHsKKwl7IDB4MTBmMDAwLCAxLCAweDAwMDAwMDQyIH0sCisJeyAweDE3ZTAz MCwgMSwgMHgwMDAwMDA0NCB9LAorCXsgMHgxN2UwNDAsIDEsIDB4MDAwMDAwNDQgfSwKKwl7fQor fTsKKworY29uc3Qgc3RydWN0IG52a21fdGhlcm1fY2xrZ2F0ZV9pbml0CitnazEwNF9mYl9jbGtn YXRlX2JsY2dfaW5pdF9iY2FzdF8wW10gPSB7CisJeyAweDE3ZWE2MCwgNCwgMHgwMDAwMDA0NCB9 LAorCXt9Cit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IG52a21fdGhlcm1fY2xrZ2F0ZV9wYWNr CitnazEwNF9mYl9jbGtnYXRlX3BhY2tbXSA9IHsKKwl7IGdrMTA0X2ZiX2Nsa2dhdGVfYmxjZ19p bml0X3Vua18wIH0sCisJeyBnazEwNF9mYl9jbGtnYXRlX2JsY2dfaW5pdF92bV8wIH0sCisJeyBn azEwNF9mYl9jbGtnYXRlX2JsY2dfaW5pdF9tYWluXzAgfSwKKwl7IGdrMTA0X2ZiX2Nsa2dhdGVf YmxjZ19pbml0X2JjYXN0XzAgfSwKKwl7fQorfTsKKwogc3RhdGljIGNvbnN0IHN0cnVjdCBudmtt X2ZiX2Z1bmMKIGdrMTA0X2ZiID0gewogCS5kdG9yID0gZ2YxMDBfZmJfZHRvciwKQEAgLTMzLDYg Kzc5LDcgQEAgZ2sxMDRfZmIgPSB7CiAJLmludHIgPSBnZjEwMF9mYl9pbnRyLAogCS5yYW1fbmV3 ID0gZ2sxMDRfcmFtX25ldywKIAkuZGVmYXVsdF9iaWdwYWdlID0gMTcsCisJLmNsa2dhdGVfcGFj ayA9IGdrMTA0X2ZiX2Nsa2dhdGVfcGFjaywKIH07CiAKIGludApkaWZmIC0tZ2l0IGEvZHJpdmVy cy9ncHUvZHJtL25vdXZlYXUvbnZrbS9zdWJkZXYvZmIvZ2sxMDQuaCBiL2RyaXZlcnMvZ3B1L2Ry bS9ub3V2ZWF1L252a20vc3ViZGV2L2ZiL2drMTA0LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwLi5iM2M3OGU0ZmY3MDYKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJz L2dwdS9kcm0vbm91dmVhdS9udmttL3N1YmRldi9mYi9nazEwNC5oCkBAIC0wLDAgKzEsMzUgQEAK Ky8qCisgKiBDb3B5cmlnaHQgMjAxOCBSZWQgSGF0IEluYy4KKyAqCisgKiBQZXJtaXNzaW9uIGlz IGhlcmVieSBncmFudGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiBvYnRhaW5pbmcg YQorICogY29weSBvZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRpb24g ZmlsZXMgKHRoZSAiU29mdHdhcmUiKSwKKyAqIHRvIGRlYWwgaW4gdGhlIFNvZnR3YXJlIHdpdGhv dXQgcmVzdHJpY3Rpb24sIGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24KKyAqIHRoZSByaWdo dHMgdG8gdXNlLCBjb3B5LCBtb2RpZnksIG1lcmdlLCBwdWJsaXNoLCBkaXN0cmlidXRlLCBzdWJs aWNlbnNlLAorICogYW5kL29yIHNlbGwgY29waWVzIG9mIHRoZSBTb2Z0d2FyZSwgYW5kIHRvIHBl cm1pdCBwZXJzb25zIHRvIHdob20gdGhlCisgKiBTb2Z0d2FyZSBpcyBmdXJuaXNoZWQgdG8gZG8g c28sIHN1YmplY3QgdG8gdGhlIGZvbGxvd2luZyBjb25kaXRpb25zOgorICoKKyAqIFRoZSBhYm92 ZSBjb3B5cmlnaHQgbm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIHNoYWxsIGJlIGlu Y2x1ZGVkIGluCisgKiBhbGwgY29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25zIG9mIHRoZSBT b2Z0d2FyZS4KKyAqCisgKiBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgIkFTIElTIiwgV0lUSE9V VCBXQVJSQU5UWSBPRiBBTlkgS0lORCwgRVhQUkVTUyBPUgorICogSU1QTElFRCwgSU5DTFVESU5H IEJVVCBOT1QgTElNSVRFRCBUTyBUSEUgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFksCisg KiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBTkQgTk9OSU5GUklOR0VNRU5ULiAg SU4gTk8gRVZFTlQgU0hBTEwKKyAqIFRIRSBDT1BZUklHSFQgSE9MREVSKFMpIE9SIEFVVEhPUihT KSBCRSBMSUFCTEUgRk9SIEFOWSBDTEFJTSwgREFNQUdFUyBPUgorICogT1RIRVIgTElBQklMSVRZ LCBXSEVUSEVSIElOIEFOIEFDVElPTiBPRiBDT05UUkFDVCwgVE9SVCBPUiBPVEhFUldJU0UsCisg KiBBUklTSU5HIEZST00sIE9VVCBPRiBPUiBJTiBDT05ORUNUSU9OIFdJVEggVEhFIFNPRlRXQVJF IE9SIFRIRSBVU0UgT1IKKyAqIE9USEVSIERFQUxJTkdTIElOIFRIRSBTT0ZUV0FSRS4KKyAqCisg KiBBdXRob3JzOiBMeXVkZSBQYXVsCisgKi8KKworI2lmbmRlZiBfX0dLMTA0X0ZCX0hfXworI2Rl ZmluZSBfX0dLMTA0X0ZCX0hfXworCisjaW5jbHVkZSA8c3ViZGV2L3RoZXJtLmg+CisKK2V4dGVy biBjb25zdCBzdHJ1Y3QgbnZrbV90aGVybV9jbGtnYXRlX2luaXQgZ2sxMDRfZmJfY2xrZ2F0ZV9i bGNnX2luaXRfdW5rXzBbXTsKK2V4dGVybiBjb25zdCBzdHJ1Y3QgbnZrbV90aGVybV9jbGtnYXRl X2luaXQgZ2sxMDRfZmJfY2xrZ2F0ZV9ibGNnX2luaXRfdm1fMFtdOworZXh0ZXJuIGNvbnN0IHN0 cnVjdCBudmttX3RoZXJtX2Nsa2dhdGVfaW5pdCBnazEwNF9mYl9jbGtnYXRlX2JsY2dfaW5pdF9t YWluXzBbXTsKK2V4dGVybiBjb25zdCBzdHJ1Y3QgbnZrbV90aGVybV9jbGtnYXRlX2luaXQgZ2sx MDRfZmJfY2xrZ2F0ZV9ibGNnX2luaXRfYmNhc3RfMFtdOworCisjZW5kaWYKZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20vc3ViZGV2L2ZiL3ByaXYuaCBiL2RyaXZlcnMv Z3B1L2RybS9ub3V2ZWF1L252a20vc3ViZGV2L2ZiL3ByaXYuaAppbmRleCA5MzUxMTg4ZDVkNzYu LjQxNGE0MjNlMGU1NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZrbS9z dWJkZXYvZmIvcHJpdi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20vc3ViZGV2 L2ZiL3ByaXYuaApAQCAtMyw2ICszLDcgQEAKICNkZWZpbmUgX19OVktNX0ZCX1BSSVZfSF9fCiAj ZGVmaW5lIG52a21fZmIocCkgY29udGFpbmVyX29mKChwKSwgc3RydWN0IG52a21fZmIsIHN1YmRl dikKICNpbmNsdWRlIDxzdWJkZXYvZmIuaD4KKyNpbmNsdWRlIDxzdWJkZXYvdGhlcm0uaD4KIHN0 cnVjdCBudmttX2Jpb3M7CiAKIHN0cnVjdCBudmttX2ZiX2Z1bmMgewpAQCAtMjcsNiArMjgsNyBA QCBzdHJ1Y3QgbnZrbV9mYl9mdW5jIHsKIAlpbnQgKCpyYW1fbmV3KShzdHJ1Y3QgbnZrbV9mYiAq LCBzdHJ1Y3QgbnZrbV9yYW0gKiopOwogCiAJdTggZGVmYXVsdF9iaWdwYWdlOworCWNvbnN0IHN0 cnVjdCBudmttX3RoZXJtX2Nsa2dhdGVfcGFjayAqY2xrZ2F0ZV9wYWNrOwogfTsKIAogdm9pZCBu dmttX2ZiX2N0b3IoY29uc3Qgc3RydWN0IG52a21fZmJfZnVuYyAqLCBzdHJ1Y3QgbnZrbV9kZXZp Y2UgKmRldmljZSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20vc3Vi ZGV2L3RoZXJtL0tidWlsZCBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20vc3ViZGV2L3Ro ZXJtL0tidWlsZAppbmRleCA0YmFjNDc3MmQ4ZWQuLjU1MDcwMmVhYjBiMSAxMDA2NDQKLS0tIGEv ZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZrbS9zdWJkZXYvdGhlcm0vS2J1aWxkCisrKyBiL2Ry aXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20vc3ViZGV2L3RoZXJtL0tidWlsZApAQCAtOSw2ICs5 LDcgQEAgbnZrbS15ICs9IG52a20vc3ViZGV2L3RoZXJtL252NDAubwogbnZrbS15ICs9IG52a20v c3ViZGV2L3RoZXJtL252NTAubwogbnZrbS15ICs9IG52a20vc3ViZGV2L3RoZXJtL2c4NC5vCiBu dmttLXkgKz0gbnZrbS9zdWJkZXYvdGhlcm0vZ3QyMTUubworbnZrbS15ICs9IG52a20vc3ViZGV2 L3RoZXJtL2dmMTAwLm8KIG52a20teSArPSBudmttL3N1YmRldi90aGVybS9nZjExOS5vCiBudmtt LXkgKz0gbnZrbS9zdWJkZXYvdGhlcm0vZ2sxMDQubwogbnZrbS15ICs9IG52a20vc3ViZGV2L3Ro ZXJtL2dtMTA3Lm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20vc3Vi ZGV2L3RoZXJtL2Jhc2UuYyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20vc3ViZGV2L3Ro ZXJtL2Jhc2UuYwppbmRleCBlNGM5NmU0NmRiOGYuLmJmNjIzMDM1NzFiMyAxMDA2NDQKLS0tIGEv ZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZrbS9zdWJkZXYvdGhlcm0vYmFzZS5jCisrKyBiL2Ry aXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20vc3ViZGV2L3RoZXJtL2Jhc2UuYwpAQCAtMzkxLDYg KzM5MSwxNiBAQCBudmttX3RoZXJtX2luaXQoc3RydWN0IG52a21fc3ViZGV2ICpzdWJkZXYpCiAJ cmV0dXJuIDA7CiB9CiAKK3ZvaWQKK252a21fdGhlcm1fY2xrZ2F0ZV9pbml0KHN0cnVjdCBudmtt X3RoZXJtICp0aGVybSwKKwkJCWNvbnN0IHN0cnVjdCBudmttX3RoZXJtX2Nsa2dhdGVfcGFjayAq cCkKK3sKKwlpZiAoIXRoZXJtLT5mdW5jLT5jbGtnYXRlX2luaXQgfHwgIXRoZXJtLT5jbGtnYXRp bmdfZW5hYmxlZCkKKwkJcmV0dXJuOworCisJdGhlcm0tPmZ1bmMtPmNsa2dhdGVfaW5pdCh0aGVy bSwgcCk7Cit9CisKIHN0YXRpYyB2b2lkICoKIG52a21fdGhlcm1fZHRvcihzdHJ1Y3QgbnZrbV9z dWJkZXYgKnN1YmRldikKIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252 a20vc3ViZGV2L3RoZXJtL2dmMTAwLmMgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmttL3N1 YmRldi90aGVybS9nZjEwMC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MC4uOTcxNjIzNDA0MzExCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL25vdXZl YXUvbnZrbS9zdWJkZXYvdGhlcm0vZ2YxMDAuYwpAQCAtMCwwICsxLDY3IEBACisvKgorICogQ29w eXJpZ2h0IDIwMTggUmVkIEhhdCBJbmMuCisgKgorICogUGVybWlzc2lvbiBpcyBoZXJlYnkgZ3Jh bnRlZCwgZnJlZSBvZiBjaGFyZ2UsIHRvIGFueSBwZXJzb24gb2J0YWluaW5nIGEKKyAqIGNvcHkg b2YgdGhpcyBzb2Z0d2FyZSBhbmQgYXNzb2NpYXRlZCBkb2N1bWVudGF0aW9uIGZpbGVzICh0aGUg IlNvZnR3YXJlIiksCisgKiB0byBkZWFsIGluIHRoZSBTb2Z0d2FyZSB3aXRob3V0IHJlc3RyaWN0 aW9uLCBpbmNsdWRpbmcgd2l0aG91dCBsaW1pdGF0aW9uCisgKiB0aGUgcmlnaHRzIHRvIHVzZSwg Y29weSwgbW9kaWZ5LCBtZXJnZSwgcHVibGlzaCwgZGlzdHJpYnV0ZSwgc3VibGljZW5zZSwKKyAq IGFuZC9vciBzZWxsIGNvcGllcyBvZiB0aGUgU29mdHdhcmUsIGFuZCB0byBwZXJtaXQgcGVyc29u cyB0byB3aG9tIHRoZQorICogU29mdHdhcmUgaXMgZnVybmlzaGVkIHRvIGRvIHNvLCBzdWJqZWN0 IHRvIHRoZSBmb2xsb3dpbmcgY29uZGl0aW9uczoKKyAqCisgKiBUaGUgYWJvdmUgY29weXJpZ2h0 IG5vdGljZSBhbmQgdGhpcyBwZXJtaXNzaW9uIG5vdGljZSBzaGFsbCBiZSBpbmNsdWRlZCBpbgor ICogYWxsIGNvcGllcyBvciBzdWJzdGFudGlhbCBwb3J0aW9ucyBvZiB0aGUgU29mdHdhcmUuCisg KgorICogVEhFIFNPRlRXQVJFIElTIFBST1ZJREVEICJBUyBJUyIsIFdJVEhPVVQgV0FSUkFOVFkg T0YgQU5ZIEtJTkQsIEVYUFJFU1MgT1IKKyAqIElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJ TUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZLAorICogRklUTkVTUyBG T1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC4gIElOIE5PIEVWRU5U IFNIQUxMCisgKiBUSEUgQ09QWVJJR0hUIEhPTERFUihTKSBPUiBBVVRIT1IoUykgQkUgTElBQkxF IEZPUiBBTlkgQ0xBSU0sIERBTUFHRVMgT1IKKyAqIE9USEVSIExJQUJJTElUWSwgV0hFVEhFUiBJ TiBBTiBBQ1RJT04gT0YgQ09OVFJBQ1QsIFRPUlQgT1IgT1RIRVJXSVNFLAorICogQVJJU0lORyBG Uk9NLCBPVVQgT0YgT1IgSU4gQ09OTkVDVElPTiBXSVRIIFRIRSBTT0ZUV0FSRSBPUiBUSEUgVVNF IE9SCisgKiBPVEhFUiBERUFMSU5HUyBJTiBUSEUgU09GVFdBUkUuCisgKgorICogQXV0aG9yczog THl1ZGUgUGF1bAorICovCisjaW5jbHVkZSA8Y29yZS9kZXZpY2UuaD4KKworI2luY2x1ZGUgInBy aXYuaCIKKwordm9pZAorZ2YxMDBfY2xrZ2F0ZV9pbml0KHN0cnVjdCBudmttX3RoZXJtICp0aGVy bSwKKwkJICAgY29uc3Qgc3RydWN0IG52a21fdGhlcm1fY2xrZ2F0ZV9wYWNrICpwKQoreworCXN0 cnVjdCBudmttX2RldmljZSAqZGV2aWNlID0gdGhlcm0tPnN1YmRldi5kZXZpY2U7CisJaW50IGk7 CisJdTMyIG5leHQsIGFkZHI7CisKKwlmb3IgKGkgPSAwOyBpOyBpKyspIHsKKwkJbmV4dCA9IHAt PmluaXRbaV0uYWRkciArIHAtPmluaXRbaV0uY291bnQgKiA4OworCQlhZGRyID0gcC0+aW5pdFtp XS5hZGRyOworCisJCXdoaWxlIChhZGRyIDwgbmV4dCkgeworCQkJbnZrbV93cjMyKGRldmljZSwg YWRkciwgcC0+aW5pdFtpXS5kYXRhKTsKKwkJCWFkZHIgKz0gODsKKwkJfQorCX0KK30KKworc3Rh dGljIGNvbnN0IHN0cnVjdCBudmttX3RoZXJtX2Z1bmMKK2dmMTAwX3RoZXJtX2Z1bmMgPSB7CisJ LmluaXQgPSBndDIxNV90aGVybV9pbml0LAorCS5maW5pID0gZzg0X3RoZXJtX2ZpbmksCisJLnB3 bV9jdHJsID0gbnY1MF9mYW5fcHdtX2N0cmwsCisJLnB3bV9nZXQgPSBudjUwX2Zhbl9wd21fZ2V0 LAorCS5wd21fc2V0ID0gbnY1MF9mYW5fcHdtX3NldCwKKwkucHdtX2Nsb2NrID0gbnY1MF9mYW5f cHdtX2Nsb2NrLAorCS50ZW1wX2dldCA9IGc4NF90ZW1wX2dldCwKKwkuZmFuX3NlbnNlID0gZ3Qy MTVfdGhlcm1fZmFuX3NlbnNlLAorCS5wcm9ncmFtX2FsYXJtcyA9IG52a21fdGhlcm1fcHJvZ3Jh bV9hbGFybXNfcG9sbGluZywKKwkvKiBUT0RPOiBGZXJtaSBjbG9ja2dhdGluZyBpc24ndCB1bmRl cnN0b29kIGZ1bGx5IHlldCwgc28gd2UgbGVhdmUgaXQKKwkgKiBkaXNhYmxlZCBoZXJlICovCit9 OworCitpbnQKK2dmMTAwX3RoZXJtX25ldyhzdHJ1Y3QgbnZrbV9kZXZpY2UgKmRldmljZSwgaW50 IGluZGV4LAorCQlzdHJ1Y3QgbnZrbV90aGVybSAqKnB0aGVybSkKK3sKKwlyZXR1cm4gbnZrbV90 aGVybV9uZXdfKCZnZjEwMF90aGVybV9mdW5jLCBkZXZpY2UsIGluZGV4LCBwdGhlcm0pOworfQpk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZrbS9zdWJkZXYvdGhlcm0vZ2sx MDQuYyBiL2RyaXZlcnMvZ3B1L2RybS9ub3V2ZWF1L252a20vc3ViZGV2L3RoZXJtL2drMTA0LmMK aW5kZXggNzk4MDZhNzU3ODkzLi40ZTAzOTcxZDJlM2QgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1 L2RybS9ub3V2ZWF1L252a20vc3ViZGV2L3RoZXJtL2drMTA0LmMKKysrIGIvZHJpdmVycy9ncHUv ZHJtL25vdXZlYXUvbnZrbS9zdWJkZXYvdGhlcm0vZ2sxMDQuYwpAQCAtMTAwLDYgKzEwMCw3IEBA IGdrMTA0X3RoZXJtX2Z1bmMgPSB7CiAJLnRlbXBfZ2V0ID0gZzg0X3RlbXBfZ2V0LAogCS5mYW5f c2Vuc2UgPSBndDIxNV90aGVybV9mYW5fc2Vuc2UsCiAJLnByb2dyYW1fYWxhcm1zID0gbnZrbV90 aGVybV9wcm9ncmFtX2FsYXJtc19wb2xsaW5nLAorCS5jbGtnYXRlX2luaXQgPSBnZjEwMF9jbGtn YXRlX2luaXQsCiAJLmNsa2dhdGVfZW5hYmxlID0gZ2sxMDRfY2xrZ2F0ZV9lbmFibGUsCiAJLmNs a2dhdGVfZmluaSA9IGdrMTA0X2Nsa2dhdGVfZmluaSwKIH07CmRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vbm91dmVhdS9udmttL3N1YmRldi90aGVybS9ndDIxNS5jIGIvZHJpdmVycy9ncHUv ZHJtL25vdXZlYXUvbnZrbS9zdWJkZXYvdGhlcm0vZ3QyMTUuYwppbmRleCBjMDgwOTdmMmFmZjUu LjRjYWY0MDFkMDAxYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZrbS9z dWJkZXYvdGhlcm0vZ3QyMTUuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbm91dmVhdS9udmttL3N1 YmRldi90aGVybS9ndDIxNS5jCkBAIC0zNiw3ICszNiw3IEBAIGd0MjE1X3RoZXJtX2Zhbl9zZW5z ZShzdHJ1Y3QgbnZrbV90aGVybSAqdGhlcm0pCiAJcmV0dXJuIC1FTk9ERVY7CiB9CiAKLXN0YXRp YyB2b2lkCit2b2lkCiBndDIxNV90aGVybV9pbml0KHN0cnVjdCBudmttX3RoZXJtICp0aGVybSkK IHsKIAlzdHJ1Y3QgbnZrbV9kZXZpY2UgKmRldmljZSA9IHRoZXJtLT5zdWJkZXYuZGV2aWNlOwpk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZrbS9zdWJkZXYvdGhlcm0vcHJp di5oIGIvZHJpdmVycy9ncHUvZHJtL25vdXZlYXUvbnZrbS9zdWJkZXYvdGhlcm0vcHJpdi5oCmlu ZGV4IGYzMDIwMmRkODhlNy4uYTczN2U5YjhhNTg0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9k cm0vbm91dmVhdS9udmttL3N1YmRldi90aGVybS9wcml2LmgKKysrIGIvZHJpdmVycy9ncHUvZHJt L25vdXZlYXUvbnZrbS9zdWJkZXYvdGhlcm0vcHJpdi5oCkBAIC05Nyw2ICs5Nyw4IEBAIHN0cnVj dCBudmttX3RoZXJtX2Z1bmMgewogCiAJdm9pZCAoKnByb2dyYW1fYWxhcm1zKShzdHJ1Y3QgbnZr bV90aGVybSAqKTsKIAorCXZvaWQgKCpjbGtnYXRlX2luaXQpKHN0cnVjdCBudmttX3RoZXJtICos CisJCQkgICAgIGNvbnN0IHN0cnVjdCBudmttX3RoZXJtX2Nsa2dhdGVfcGFjayAqKTsKIAl2b2lk ICgqY2xrZ2F0ZV9lbmFibGUpKHN0cnVjdCBudmttX3RoZXJtICopOwogCXZvaWQgKCpjbGtnYXRl X2ZpbmkpKHN0cnVjdCBudmttX3RoZXJtICosIGJvb2wpOwogfTsKQEAgLTExNCw2ICsxMTYsOSBA QCB2b2lkIGc4NF90aGVybV9maW5pKHN0cnVjdCBudmttX3RoZXJtICopOwogCiBpbnQgZ3QyMTVf dGhlcm1fZmFuX3NlbnNlKHN0cnVjdCBudmttX3RoZXJtICopOwogCit2b2lkIGdmMTAwX2Nsa2dh dGVfaW5pdChzdHJ1Y3QgbnZrbV90aGVybSAqLAorCQkJY29uc3Qgc3RydWN0IG52a21fdGhlcm1f Y2xrZ2F0ZV9wYWNrICopOworCiB2b2lkIGc4NF90aGVybV9pbml0KHN0cnVjdCBudmttX3RoZXJt ICopOwogCiBpbnQgZ2YxMTlfZmFuX3B3bV9jdHJsKHN0cnVjdCBudmttX3RoZXJtICosIGludCwg Ym9vbCk7CkBAIC0xMjIsNiArMTI3LDkgQEAgaW50IGdmMTE5X2Zhbl9wd21fc2V0KHN0cnVjdCBu dmttX3RoZXJtICosIGludCwgdTMyLCB1MzIpOwogaW50IGdmMTE5X2Zhbl9wd21fY2xvY2soc3Ry dWN0IG52a21fdGhlcm0gKiwgaW50KTsKIHZvaWQgZ2YxMTlfdGhlcm1faW5pdChzdHJ1Y3QgbnZr bV90aGVybSAqKTsKIAordm9pZCBndDIxNV90aGVybV9pbml0KHN0cnVjdCBudmttX3RoZXJtICp0 aGVybSk7CisKK3ZvaWQgZ2sxMDRfdGhlcm1faW5pdChzdHJ1Y3QgbnZrbV90aGVybSAqKTsKIHZv aWQgZ2sxMDRfY2xrZ2F0ZV9lbmFibGUoc3RydWN0IG52a21fdGhlcm0gKik7CiB2b2lkIGdrMTA0 X2Nsa2dhdGVfZmluaShzdHJ1Y3QgbnZrbV90aGVybSAqLCBib29sKTsKIAotLSAKMi4xNC4zCgpf X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpOb3V2ZWF1IG1h aWxpbmcgbGlzdApOb3V2ZWF1QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZy ZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL25vdXZlYXUK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Google-Smtp-Source: AH8x224RrF7R6lIyyhjty2dKzoz+a4T4toSdHe9brDY1DjJ54au3fDv4SEvDSd/4EY0jqa6Zb+qg ARC-Seal: i=1; a=rsa-sha256; t=1516937869; cv=none; d=google.com; s=arc-20160816; b=otpfFKj9paK+DU6zWDI682cuVNF5paDx7zwcm9DA70lr82kixBt+PQoxCaGQr0NCDZ 8UMHKSOWPNx26lacCoKnMdaIUZwySu0ukHZq6l3GKrVaEj+NGkgL/tt3KDI89elit/G+ 4+Z1QC0P4AW4Jzvr2a+c63m1roGrHlo8//a/FnB/gIm/wkMdKkhxRny5fM0YRAAP9Js0 CsyiLT7BajPssxhbV5z4kIGlEG9+g8U/ZPtAs31HiBj0llCuwFqs/vTAOiySjF6CEJI1 0oGTtTDsgegk7UNg6HP5YS/mfHfTICaN/WHUIeHWRf+8O0GP6I0soUT4EzVuVIrvyPc8 bAsg== 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=E8af6Zg91YAeWVEMdSHuBq5H8DEBKInwKkNO6PMnivc=; b=ZiIJu203lCpWkOjjUb+7Hu4Ix+0pirb8V9vO77TO6i2GB53HkrpjeO5V+x1i3b3OGg 1jK1v4cKFU7F5Pe5lEt1xNFVyZExX8ygjlx8bZWv0kbNwHaaxuwJuySV+aEQLmasjE+b 5YETL5VLURJIPoKna4aJaYAwOgwptcTidEooMJvd90ymcL9hTO3FIf67ZJHMLOGX0RUm QW8/7coQc0d1jaGe85gqFA8Mks0dvyN8QVGSW19EtlrcUUEy1FnMC7SmAZqApWXuZJjB V5NFvyFk3EI+mWTt2wzDcXv9GL4DqZw+jEunf322pFqxL/AMeISlxRNKu63MArKQqeF6 xj6A== 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 , Thomas Gleixner , Kate Stewart , Philippe Ombredanne , Rhys Kidd , Karol Herbst , Greg Kroah-Hartman , Alexandre Courbot , Martin Peres , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org Subject: [RFC v2 2/4] drm/nouveau: Add support for BLCG on Kepler1 Date: Thu, 25 Jan 2018 22:35:04 -0500 Message-Id: <20180126033607.7682-3-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?1590624643094697775?= X-GMAIL-MSGID: =?utf-8?q?1590624643094697775?= X-Mailing-List: linux-kernel@vger.kernel.org List-ID: This enables BLCG optimization for kepler1. When using clockgating, nvidia's firmware has a set of registers which are initially programmed by the vbios with various engine delays and other mysterious settings that are safe enough to bring up the GPU. However, the values used by the vbios are more power hungry then they need to be, so the nvidia driver writes it's own more optimized set of BLCG settings before enabling CG_CTRL. This adds support for programming the optimized BLCG values during engine/subdev init, which enables rather significant power savings. This introduces the nvkm_therm_clkgate_init() helper, which we use to program the optimized BLCG settings before enabling clockgating with nvkm_therm_clkgate_enable. As well, this commit shares a lot more code with Fermi since BLCG is mostly the same there as far as we can tell. In the future, it's likely we'll reformat the clkgate_packs for kepler1 so that they share a list of mmio packs with Fermi. Signed-off-by: Lyude Paul --- .../gpu/drm/nouveau/include/nvkm/subdev/therm.h | 12 ++ drivers/gpu/drm/nouveau/nvkm/engine/gr/gf100.h | 1 + drivers/gpu/drm/nouveau/nvkm/engine/gr/gk104.c | 207 +++++++++++++++++++++ drivers/gpu/drm/nouveau/nvkm/engine/gr/gk104.h | 55 ++++++ drivers/gpu/drm/nouveau/nvkm/subdev/fb/gf100.c | 6 + drivers/gpu/drm/nouveau/nvkm/subdev/fb/gk104.c | 47 +++++ drivers/gpu/drm/nouveau/nvkm/subdev/fb/gk104.h | 35 ++++ drivers/gpu/drm/nouveau/nvkm/subdev/fb/priv.h | 2 + drivers/gpu/drm/nouveau/nvkm/subdev/therm/Kbuild | 1 + drivers/gpu/drm/nouveau/nvkm/subdev/therm/base.c | 10 + drivers/gpu/drm/nouveau/nvkm/subdev/therm/gf100.c | 67 +++++++ drivers/gpu/drm/nouveau/nvkm/subdev/therm/gk104.c | 1 + drivers/gpu/drm/nouveau/nvkm/subdev/therm/gt215.c | 2 +- drivers/gpu/drm/nouveau/nvkm/subdev/therm/priv.h | 8 + 14 files changed, 453 insertions(+), 1 deletion(-) create mode 100644 drivers/gpu/drm/nouveau/nvkm/engine/gr/gk104.h create mode 100644 drivers/gpu/drm/nouveau/nvkm/subdev/fb/gk104.h create mode 100644 drivers/gpu/drm/nouveau/nvkm/subdev/therm/gf100.c diff --git a/drivers/gpu/drm/nouveau/include/nvkm/subdev/therm.h b/drivers/gpu/drm/nouveau/include/nvkm/subdev/therm.h index 240b19bb4667..9398d9f09339 100644 --- a/drivers/gpu/drm/nouveau/include/nvkm/subdev/therm.h +++ b/drivers/gpu/drm/nouveau/include/nvkm/subdev/therm.h @@ -46,6 +46,16 @@ enum nvkm_therm_attr_type { NVKM_THERM_ATTR_THRS_SHUTDOWN_HYST = 17, }; +struct nvkm_therm_clkgate_init { + u32 addr; + u8 count; + u32 data; +}; + +struct nvkm_therm_clkgate_pack { + const struct nvkm_therm_clkgate_init *init; +}; + struct nvkm_therm { const struct nvkm_therm_func *func; struct nvkm_subdev subdev; @@ -92,6 +102,8 @@ struct nvkm_therm { 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_init(struct nvkm_therm *, + const struct nvkm_therm_clkgate_pack *); void nvkm_therm_clkgate_enable(struct nvkm_therm *); void nvkm_therm_clkgate_fini(struct nvkm_therm *, bool); diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/gr/gf100.h b/drivers/gpu/drm/nouveau/nvkm/engine/gr/gf100.h index d7c2adb9b543..c8ec3fd97155 100644 --- a/drivers/gpu/drm/nouveau/nvkm/engine/gr/gf100.h +++ b/drivers/gpu/drm/nouveau/nvkm/engine/gr/gf100.h @@ -137,6 +137,7 @@ struct gf100_gr_func { int (*rops)(struct gf100_gr *); int ppc_nr; const struct gf100_grctx_func *grctx; + const struct nvkm_therm_clkgate_pack *clkgate_pack; struct nvkm_sclass sclass[]; }; diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/gr/gk104.c b/drivers/gpu/drm/nouveau/nvkm/engine/gr/gk104.c index 5e82f94c2245..17cea9c70f7f 100644 --- a/drivers/gpu/drm/nouveau/nvkm/engine/gr/gk104.c +++ b/drivers/gpu/drm/nouveau/nvkm/engine/gr/gk104.c @@ -22,6 +22,7 @@ * Authors: Ben Skeggs */ #include "gf100.h" +#include "gk104.h" #include "ctxgf100.h" #include @@ -173,6 +174,208 @@ gk104_gr_pack_mmio[] = { {} }; +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_main_0[] = { + { 0x4041f0, 1, 0x00004046 }, + { 0x409890, 1, 0x00000045 }, + { 0x4098b0, 1, 0x0000007f }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_rstr2d_0[] = { + { 0x4078c0, 1, 0x00000042 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_unk_0[] = { + { 0x406000, 1, 0x00004044 }, + { 0x405860, 1, 0x00004042 }, + { 0x40590c, 1, 0x00004042 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_gcc_0[] = { + { 0x408040, 1, 0x00004044 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_sked_0[] = { + { 0x407000, 1, 0x00004044 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_unk_1[] = { + { 0x405bf0, 1, 0x00004044 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_gpc_ctxctl_0[] = { + { 0x41a890, 1, 0x00000042 }, + { 0x41a8b0, 1, 0x0000007f }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_gpc_unk_0[] = { + { 0x418500, 1, 0x00004042 }, + { 0x418608, 1, 0x00004042 }, + { 0x418688, 1, 0x00004042 }, + { 0x418718, 1, 0x00000042 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_gpc_esetup_0[] = { + { 0x418828, 1, 0x00000044 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_gpc_tpbus_0[] = { + { 0x418bbc, 1, 0x00004042 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_gpc_zcull_0[] = { + { 0x418970, 1, 0x00004042 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_gpc_tpconf_0[] = { + { 0x418c70, 1, 0x00004042 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_gpc_unk_1[] = { + { 0x418cf0, 1, 0x00004042 }, + { 0x418d70, 1, 0x00004042 }, + { 0x418f0c, 1, 0x00004042 }, + { 0x418e0c, 1, 0x00004042 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_gpc_gcc_0[] = { + { 0x419020, 1, 0x00004042 }, + { 0x419038, 1, 0x00000042 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_gpc_ffb_0[] = { + { 0x418898, 1, 0x00000042 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_gpc_tex_0[] = { + { 0x419a40, 9, 0x00004042 }, + { 0x419acc, 1, 0x00004047 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_gpc_poly_0[] = { + { 0x419868, 1, 0x00000042 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_gpc_l1c_0[] = { + { 0x419ccc, 3, 0x00000042 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_gpc_unk_2[] = { + { 0x419c70, 1, 0x00004045 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_gpc_mp_0[] = { + { 0x419fd0, 1, 0x00004043 }, + { 0x419fd8, 1, 0x00004049 }, + { 0x419fe0, 2, 0x00004042 }, + { 0x419ff0, 1, 0x00004046 }, + { 0x419ff8, 1, 0x00004042 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_gpc_ppc_0[] = { + { 0x41be28, 1, 0x00000042 }, + { 0x41bfe8, 1, 0x00004042 }, + { 0x41bed0, 1, 0x00004042 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_rop_zrop_0[] = { + { 0x408810, 2, 0x00004042 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_rop_0[] = { + { 0x408a80, 6, 0x00004042 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_rop_crop_0[] = { + { 0x4089a8, 1, 0x00004042 }, + { 0x4089b0, 1, 0x00000042 }, + { 0x4089b8, 1, 0x00004042 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_clkgate_blcg_init_pxbar_0[] = { + { 0x13c820, 1, 0x0001007f }, + { 0x13cbe0, 1, 0x00000042 }, + {} +}; + +const struct nvkm_therm_clkgate_pack +gk104_clkgate_pack[] = { + { gk104_clkgate_blcg_init_main_0 }, + { gk104_clkgate_blcg_init_rstr2d_0 }, + { gk104_clkgate_blcg_init_unk_0 }, + { gk104_clkgate_blcg_init_gcc_0 }, + { gk104_clkgate_blcg_init_sked_0 }, + { gk104_clkgate_blcg_init_unk_1 }, + { gk104_clkgate_blcg_init_gpc_ctxctl_0 }, + { gk104_clkgate_blcg_init_gpc_unk_0 }, + { gk104_clkgate_blcg_init_gpc_esetup_0 }, + { gk104_clkgate_blcg_init_gpc_tpbus_0 }, + { gk104_clkgate_blcg_init_gpc_zcull_0 }, + { gk104_clkgate_blcg_init_gpc_tpconf_0 }, + { gk104_clkgate_blcg_init_gpc_unk_1 }, + { gk104_clkgate_blcg_init_gpc_gcc_0 }, + { gk104_clkgate_blcg_init_gpc_ffb_0 }, + { gk104_clkgate_blcg_init_gpc_tex_0 }, + { gk104_clkgate_blcg_init_gpc_poly_0 }, + { gk104_clkgate_blcg_init_gpc_l1c_0 }, + { gk104_clkgate_blcg_init_gpc_unk_2 }, + { gk104_clkgate_blcg_init_gpc_mp_0 }, + { gk104_clkgate_blcg_init_gpc_ppc_0 }, + { gk104_clkgate_blcg_init_rop_zrop_0 }, + { gk104_clkgate_blcg_init_rop_0 }, + { gk104_clkgate_blcg_init_rop_crop_0 }, + { gk104_clkgate_blcg_init_pxbar_0 }, + {} +}; + /******************************************************************************* * PGRAPH engine/subdev functions ******************************************************************************/ @@ -214,6 +417,9 @@ gk104_gr_init(struct gf100_gr *gr) gr->func->init_gpc_mmu(gr); gf100_gr_mmio(gr, gr->func->mmio); + if (gr->func->clkgate_pack) + nvkm_therm_clkgate_init(gr->base.engine.subdev.device->therm, + gr->func->clkgate_pack); nvkm_wr32(device, GPC_UNIT(0, 0x3018), 0x00000001); @@ -338,6 +544,7 @@ gk104_gr = { .rops = gf100_gr_rops, .ppc_nr = 1, .grctx = &gk104_grctx, + .clkgate_pack = gk104_clkgate_pack, .sclass = { { -1, -1, FERMI_TWOD_A }, { -1, -1, KEPLER_INLINE_TO_MEMORY_A }, diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/gr/gk104.h b/drivers/gpu/drm/nouveau/nvkm/engine/gr/gk104.h new file mode 100644 index 000000000000..a24c177365d1 --- /dev/null +++ b/drivers/gpu/drm/nouveau/nvkm/engine/gr/gk104.h @@ -0,0 +1,55 @@ +/* + * 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_GR_H__ +#define __GK104_GR_H__ + +#include + +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_main_0[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_rstr2d_0[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_unk_0[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_gcc_0[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_sked_0[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_unk_1[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_gpc_ctxctl_0[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_gpc_unk_0[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_gpc_esetup_0[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_gpc_tpbus_0[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_gpc_zcull_0[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_gpc_tpconf_0[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_gpc_unk_1[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_gpc_gcc_0[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_gpc_ffb_0[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_gpc_tex_0[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_gpc_poly_0[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_gpc_l1c_0[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_gpc_unk_2[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_gpc_mp_0[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_gpc_ppc_0[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_rop_zrop_0[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_rop_0[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_rop_crop_0[]; +extern const struct nvkm_therm_clkgate_init gk104_clkgate_blcg_init_pxbar_0[]; + +#endif diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/fb/gf100.c b/drivers/gpu/drm/nouveau/nvkm/subdev/fb/gf100.c index 47d28c279707..cdc4e0a2cc6b 100644 --- a/drivers/gpu/drm/nouveau/nvkm/subdev/fb/gf100.c +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/fb/gf100.c @@ -26,6 +26,7 @@ #include #include +#include void gf100_fb_intr(struct nvkm_fb *base) @@ -92,6 +93,11 @@ gf100_fb_init(struct nvkm_fb *base) if (fb->r100c10_page) nvkm_wr32(device, 0x100c10, fb->r100c10 >> 8); + + if (base->func->clkgate_pack) { + nvkm_therm_clkgate_init(device->therm, + base->func->clkgate_pack); + } } void * diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/fb/gk104.c b/drivers/gpu/drm/nouveau/nvkm/subdev/fb/gk104.c index 0a6e8eaad42c..48fd98e08baa 100644 --- a/drivers/gpu/drm/nouveau/nvkm/subdev/fb/gk104.c +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/fb/gk104.c @@ -20,10 +20,56 @@ * OTHER DEALINGS IN THE SOFTWARE. * * Authors: Ben Skeggs + * Lyude Paul */ +#include "gk104.h" #include "gf100.h" #include "ram.h" +/* + ******************************************************************************* + * PGRAPH registers for clockgating + ******************************************************************************* + */ +const struct nvkm_therm_clkgate_init +gk104_fb_clkgate_blcg_init_unk_0[] = { + { 0x100d10, 1, 0x0000c244 }, + { 0x100d30, 1, 0x0000c242 }, + { 0x100d3c, 1, 0x00000242 }, + { 0x100d48, 1, 0x00000242 }, + { 0x100d1c, 1, 0x00000042 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_fb_clkgate_blcg_init_vm_0[] = { + { 0x100c98, 1, 0x00000242 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_fb_clkgate_blcg_init_main_0[] = { + { 0x10f000, 1, 0x00000042 }, + { 0x17e030, 1, 0x00000044 }, + { 0x17e040, 1, 0x00000044 }, + {} +}; + +const struct nvkm_therm_clkgate_init +gk104_fb_clkgate_blcg_init_bcast_0[] = { + { 0x17ea60, 4, 0x00000044 }, + {} +}; + +static const struct nvkm_therm_clkgate_pack +gk104_fb_clkgate_pack[] = { + { gk104_fb_clkgate_blcg_init_unk_0 }, + { gk104_fb_clkgate_blcg_init_vm_0 }, + { gk104_fb_clkgate_blcg_init_main_0 }, + { gk104_fb_clkgate_blcg_init_bcast_0 }, + {} +}; + static const struct nvkm_fb_func gk104_fb = { .dtor = gf100_fb_dtor, @@ -33,6 +79,7 @@ gk104_fb = { .intr = gf100_fb_intr, .ram_new = gk104_ram_new, .default_bigpage = 17, + .clkgate_pack = gk104_fb_clkgate_pack, }; int diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/fb/gk104.h b/drivers/gpu/drm/nouveau/nvkm/subdev/fb/gk104.h new file mode 100644 index 000000000000..b3c78e4ff706 --- /dev/null +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/fb/gk104.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 __GK104_FB_H__ +#define __GK104_FB_H__ + +#include + +extern const struct nvkm_therm_clkgate_init gk104_fb_clkgate_blcg_init_unk_0[]; +extern const struct nvkm_therm_clkgate_init gk104_fb_clkgate_blcg_init_vm_0[]; +extern const struct nvkm_therm_clkgate_init gk104_fb_clkgate_blcg_init_main_0[]; +extern const struct nvkm_therm_clkgate_init gk104_fb_clkgate_blcg_init_bcast_0[]; + +#endif diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/fb/priv.h b/drivers/gpu/drm/nouveau/nvkm/subdev/fb/priv.h index 9351188d5d76..414a423e0e55 100644 --- a/drivers/gpu/drm/nouveau/nvkm/subdev/fb/priv.h +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/fb/priv.h @@ -3,6 +3,7 @@ #define __NVKM_FB_PRIV_H__ #define nvkm_fb(p) container_of((p), struct nvkm_fb, subdev) #include +#include struct nvkm_bios; struct nvkm_fb_func { @@ -27,6 +28,7 @@ struct nvkm_fb_func { int (*ram_new)(struct nvkm_fb *, struct nvkm_ram **); u8 default_bigpage; + const struct nvkm_therm_clkgate_pack *clkgate_pack; }; void nvkm_fb_ctor(const struct nvkm_fb_func *, struct nvkm_device *device, diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/Kbuild b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/Kbuild index 4bac4772d8ed..550702eab0b1 100644 --- a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/Kbuild +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/Kbuild @@ -9,6 +9,7 @@ nvkm-y += nvkm/subdev/therm/nv40.o 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/gf100.o nvkm-y += nvkm/subdev/therm/gf119.o nvkm-y += nvkm/subdev/therm/gk104.o nvkm-y += nvkm/subdev/therm/gm107.o diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/base.c b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/base.c index e4c96e46db8f..bf62303571b3 100644 --- a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/base.c +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/base.c @@ -391,6 +391,16 @@ nvkm_therm_init(struct nvkm_subdev *subdev) return 0; } +void +nvkm_therm_clkgate_init(struct nvkm_therm *therm, + const struct nvkm_therm_clkgate_pack *p) +{ + if (!therm->func->clkgate_init || !therm->clkgating_enabled) + return; + + therm->func->clkgate_init(therm, p); +} + static void * nvkm_therm_dtor(struct nvkm_subdev *subdev) { diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gf100.c b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gf100.c new file mode 100644 index 000000000000..971623404311 --- /dev/null +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gf100.c @@ -0,0 +1,67 @@ +/* + * 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" + +void +gf100_clkgate_init(struct nvkm_therm *therm, + const struct nvkm_therm_clkgate_pack *p) +{ + struct nvkm_device *device = therm->subdev.device; + int i; + u32 next, addr; + + for (i = 0; i; i++) { + next = p->init[i].addr + p->init[i].count * 8; + addr = p->init[i].addr; + + while (addr < next) { + nvkm_wr32(device, addr, p->init[i].data); + addr += 8; + } + } +} + +static const struct nvkm_therm_func +gf100_therm_func = { + .init = gt215_therm_init, + .fini = g84_therm_fini, + .pwm_ctrl = nv50_fan_pwm_ctrl, + .pwm_get = nv50_fan_pwm_get, + .pwm_set = nv50_fan_pwm_set, + .pwm_clock = nv50_fan_pwm_clock, + .temp_get = g84_temp_get, + .fan_sense = gt215_therm_fan_sense, + .program_alarms = nvkm_therm_program_alarms_polling, + /* TODO: Fermi clockgating isn't understood fully yet, so we leave it + * disabled here */ +}; + +int +gf100_therm_new(struct nvkm_device *device, int index, + struct nvkm_therm **ptherm) +{ + return nvkm_therm_new_(&gf100_therm_func, device, index, ptherm); +} diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gk104.c b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gk104.c index 79806a757893..4e03971d2e3d 100644 --- a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gk104.c +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gk104.c @@ -100,6 +100,7 @@ gk104_therm_func = { .temp_get = g84_temp_get, .fan_sense = gt215_therm_fan_sense, .program_alarms = nvkm_therm_program_alarms_polling, + .clkgate_init = gf100_clkgate_init, .clkgate_enable = gk104_clkgate_enable, .clkgate_fini = gk104_clkgate_fini, }; diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gt215.c b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gt215.c index c08097f2aff5..4caf401d001a 100644 --- a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gt215.c +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/gt215.c @@ -36,7 +36,7 @@ gt215_therm_fan_sense(struct nvkm_therm *therm) return -ENODEV; } -static void +void gt215_therm_init(struct nvkm_therm *therm) { struct nvkm_device *device = therm->subdev.device; diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/priv.h b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/priv.h index f30202dd88e7..a737e9b8a584 100644 --- a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/priv.h +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/priv.h @@ -97,6 +97,8 @@ struct nvkm_therm_func { void (*program_alarms)(struct nvkm_therm *); + void (*clkgate_init)(struct nvkm_therm *, + const struct nvkm_therm_clkgate_pack *); void (*clkgate_enable)(struct nvkm_therm *); void (*clkgate_fini)(struct nvkm_therm *, bool); }; @@ -114,6 +116,9 @@ void g84_therm_fini(struct nvkm_therm *); int gt215_therm_fan_sense(struct nvkm_therm *); +void gf100_clkgate_init(struct nvkm_therm *, + const struct nvkm_therm_clkgate_pack *); + void g84_therm_init(struct nvkm_therm *); int gf119_fan_pwm_ctrl(struct nvkm_therm *, int, bool); @@ -122,6 +127,9 @@ 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 gt215_therm_init(struct nvkm_therm *therm); + +void gk104_therm_init(struct nvkm_therm *); void gk104_clkgate_enable(struct nvkm_therm *); void gk104_clkgate_fini(struct nvkm_therm *, bool); -- 2.14.3