From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Luis R. Rodriguez" Subject: [PATCH v6 04/16] x86/rtc: replace paravirt rtc check with platform legacy quirk Date: Wed, 13 Apr 2016 17:04:34 -0700 Message-ID: <1460592286-300-5-git-send-email-mcgrof@kernel.org> References: <1460592286-300-1-git-send-email-mcgrof@kernel.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1460592286-300-1-git-send-email-mcgrof@kernel.org> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: bp@alien8.de, hpa@zytor.com, tglx@linutronix.de, mingo@redhat.com, rusty@rustcorp.com.au Cc: kozerkov@parallels.com, matt@codeblueprint.co.uk, bigeasy@linutronix.de, lv.zheng@intel.com, ffainelli@freebox.fr, mbizon@freebox.fr, xen-devel@lists.xensource.com, x86@kernel.org, robert.moore@intel.com, linux-acpi@vger.kernel.org, glin@suse.com, lenb@kernel.org, julien.grall@linaro.org, josh@joshtriplett.org, george.dunlap@citrix.com, jlee@suse.com, lguest@lists.ozlabs.org, boris.ostrovsky@oracle.com, andriy.shevchenko@linux.intel.com, jgross@suse.com, toshi.kani@hp.com, andrew.cooper3@citrix.com, rjw@rjwysocki.net, linux-kernel@vger.kernel.org, luto@amacapital.net, "Luis R. Rodriguez" , david.vrabel@citrix.com, tiwai@suse.de List-Id: linux-acpi@vger.kernel.org V2UgaGF2ZSA0IHR5cGVzIG9mIHg4NiBwbGF0Zm9ybXMgdGhhdCBkaXNhYmxlIFJUQzoKCiAgKiBJ bnRlbCBNSUQKICAqIExndWVzdCAtIHVzZXMgcGFyYXZpcnQKICAqIFhlbiBkb20tVSAtIHVzZXMg cGFyYXZpcnQKICAqIHg4NiBvbiBsZWdhY3kgc3lzdGVtcyBhbm5vdGF0ZWQgd2l0aCBhbiBBQ1BJ IGxlZ2FjeSBmbGFnCgpXZSBjYW4gY29uc29saWRhdGUgYWxsIG9mIHRoZXNlIGludG8gYSBwbGF0 Zm9ybSBzcGVjaWZpYyBsZWdhY3kKcXVpcmsgc2V0IGVhcmx5IGluIGJvb3QgdGhyb3VnaCBpMzg2 X3N0YXJ0X2tlcm5lbCgpIGFuZCB0aHJvdWdoCng4Nl82NF9zdGFydF9yZXNlcnZhdGlvbnMoKS4g VGhpcyBkZWFscyB3aXRoIHRoZSBSVEMgcXVpcmtzIHdoaWNoCndlIGNhbiByZWx5IG9uIHRocm91 Z2ggdGhlIGhhcmR3YXJlIHN1YmFyY2gsIHRoZSBBQ1BJIGNoZWNrIGNhbgpiZSBkZWFsdCB3aXRo IHNlcGFyYXRlbHkuCgpGb3IgWGVuIHRoaW5ncyBhcmUgYml0IG1vcmUgY29tcGxleCBnaXZlbiB0 aGF0IHRoZSBAWDg2X1NVQkFSQ0hfWEVOCng4Nl9oYXJkd2FyZV9zdWJhcmNoIGlzIHNoYXJlZCBv biBmb3IgWGVuIHdoaWNoIHVzZXMgdGhlIFBWIHBhdGggZm9yCmJvdGggZG9tVSBhbmQgZG9tMC4g U2luY2UgdGhlIHNlbWFudGljcyBmb3IgZGlmZmVyZW50aWF0aW5nIGJldHdlZW4KdGhlIHR3byBh cmUgWGVuIHNwZWNpZmljIHdlIHByb3ZpZGUgYSBwbGF0Zm9ybSBoZWxwZXIgdG8gaGVscCBvdmVy cmlkZQpkZWZhdWx0IGxlZ2FjeSBmZWF0dXJlcyAtLSB4ODZfcGxhdGZvcm0uc2V0X2xlZ2FjeV9m ZWF0dXJlcygpLiBVc2UKb2YgdGhpcyBoZWxwZXIgaXMgaGlnaGx5IGRpc2NvdXJhZ2VkLCBpdHMg b25seSBwdXJwb3NlIHNob3VsZCBiZQp0byBhY2NvdW50IGZvciB0aGUgbGFjayBvZiBzZW1hbnRp Y3MgYXZhaWxhYmxlIHdpdGhpbiB5b3VyIGdpdmVuCng4Nl9oYXJkd2FyZV9zdWJhcmNoLgoKQXMg cGVyIDAtZGF5LCB0aGlzIGJ1bXBzIHRoZSB2bWxpbnV4IHNpemUgdXNpbmcgaTM4Ni10aW55Y29u ZmlnIGFzCmZvbGxvd3M6CgpUT1RBTCAgIFRFWFQgICBpbml0LnRleHQgICAgeDg2X2Vhcmx5X2lu aXRfcGxhdGZvcm1fcXVpcmtzKCkKKzcwICAgICArNjIgICAgKzYyICAgICAgICAgICs0MwoKT25s eSA4IGJ5dGVzIG92ZXJoZWFkIHRvdGFsLCBhcyB0aGUgbWFpbiBpbmNyZWFzZSBpbiBzaXplIGlz CmFsbCByZW1vdmVkIHZpYSBfX2luaXQuCgp2NDogc3BsaXQgdGhlIHN1YmFyY2ggY2hlY2sgZnJv bSB0aGUgQUNQSSBjaGVjaywgY2xhcmlmeQogICAgb24gdGhlIEFDUEkgY2hhbmdlIGNvbW1pdCBs b2cgd2h5IG9yZGVyaW5nIHdvcmtzCnY1OiBhZGQgeDg2X3BsYXRmb3JtLnNldF9sZWdhY3lfZmVh dHVyZXMoKSB0byBhY2NvdW50IGZvciBkb20wLAogICAgYWRkIGFsc28gc2l6ZSBpbXBhY3Qgb24g dm1saW51eCBhcyBwZXIgMC1kYXkgcmVwb3J0CnY2OiBVc2UgX19pbml0IG9uIHhlbl9kb20wX3Nl dF9sZWdhY3lfZmVhdHVyZXMoKQoKU3VnZ2VzdGVkLWJ5OiBJbmdvIE1vbG5hciA8bWluZ29Aa2Vy bmVsLm9yZz4KU2lnbmVkLW9mZi1ieTogTHVpcyBSLiBSb2RyaWd1ZXogPG1jZ3JvZkBrZXJuZWwu b3JnPgotLS0KIGFyY2gveDg2L01ha2VmaWxlICAgICAgICAgICAgICAgICAgICAgfCAgMSArCiBh cmNoL3g4Ni9pbmNsdWRlL2FzbS9wYXJhdmlydC5oICAgICAgIHwgIDYgLS0tLS0tCiBhcmNoL3g4 Ni9pbmNsdWRlL2FzbS9wYXJhdmlydF90eXBlcy5oIHwgIDUgLS0tLS0KIGFyY2gveDg2L2luY2x1 ZGUvYXNtL3Byb2Nlc3Nvci5oICAgICAgfCAgMSAtCiBhcmNoL3g4Ni9pbmNsdWRlL2FzbS94ODZf aW5pdC5oICAgICAgIHwgMjEgKysrKysrKysrKysrKysrKysrKysrCiBhcmNoL3g4Ni9rZXJuZWwv TWFrZWZpbGUgICAgICAgICAgICAgIHwgIDYgKysrKystCiBhcmNoL3g4Ni9rZXJuZWwvaGVhZDMy LmMgICAgICAgICAgICAgIHwgIDIgKysKIGFyY2gveDg2L2tlcm5lbC9oZWFkNjQuYyAgICAgICAg ICAgICAgfCAgMSArCiBhcmNoL3g4Ni9rZXJuZWwvcGxhdGZvcm0tcXVpcmtzLmMgICAgIHwgMjEg KysrKysrKysrKysrKysrKysrKysrCiBhcmNoL3g4Ni9rZXJuZWwvcnRjLmMgICAgICAgICAgICAg ICAgIHwgIDcgKystLS0tLQogYXJjaC94ODYvbGd1ZXN0L2Jvb3QuYyAgICAgICAgICAgICAgICB8 ICAxIC0KIGFyY2gveDg2L3hlbi9lbmxpZ2h0ZW4uYyAgICAgICAgICAgICAgfCAxMCArKysrKysr LS0tCiAxMiBmaWxlcyBjaGFuZ2VkLCA2MCBpbnNlcnRpb25zKCspLCAyMiBkZWxldGlvbnMoLSkK IGNyZWF0ZSBtb2RlIDEwMDY0NCBhcmNoL3g4Ni9rZXJuZWwvcGxhdGZvcm0tcXVpcmtzLmMKCmRp ZmYgLS1naXQgYS9hcmNoL3g4Ni9NYWtlZmlsZSBiL2FyY2gveDg2L01ha2VmaWxlCmluZGV4IDQw ODZhYmNhMGIzMi4uZjllZDhhN2NlMmI2IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9NYWtlZmlsZQor KysgYi9hcmNoL3g4Ni9NYWtlZmlsZQpAQCAtMjA5LDYgKzIwOSw3IEBAIGVuZGlmCiBoZWFkLXkg Oj0gYXJjaC94ODYva2VybmVsL2hlYWRfJChCSVRTKS5vCiBoZWFkLXkgKz0gYXJjaC94ODYva2Vy bmVsL2hlYWQkKEJJVFMpLm8KIGhlYWQteSArPSBhcmNoL3g4Ni9rZXJuZWwvaGVhZC5vCitoZWFk LXkgKz0gYXJjaC94ODYva2VybmVsL3BsYXRmb3JtLXF1aXJrcy5vCiAKIGxpYnMteSAgKz0gYXJj aC94ODYvbGliLwogCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wYXJhdmlydC5o IGIvYXJjaC94ODYvaW5jbHVkZS9hc20vcGFyYXZpcnQuaAppbmRleCA2MDFmMWI4Zjk5NjEuLjZj N2E0YTE5MjAzMiAxMDA2NDQKLS0tIGEvYXJjaC94ODYvaW5jbHVkZS9hc20vcGFyYXZpcnQuaAor KysgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wYXJhdmlydC5oCkBAIC0yMCwxMiArMjAsNiBAQCBz dGF0aWMgaW5saW5lIGludCBwYXJhdmlydF9lbmFibGVkKHZvaWQpCiAJcmV0dXJuIHB2X2luZm8u cGFyYXZpcnRfZW5hYmxlZDsKIH0KIAotc3RhdGljIGlubGluZSBpbnQgcGFyYXZpcnRfaGFzX2Zl YXR1cmUodW5zaWduZWQgaW50IGZlYXR1cmUpCi17Ci0JV0FSTl9PTl9PTkNFKCFwdl9pbmZvLnBh cmF2aXJ0X2VuYWJsZWQpOwotCXJldHVybiAocHZfaW5mby5mZWF0dXJlcyAmIGZlYXR1cmUpOwot fQotCiBzdGF0aWMgaW5saW5lIHZvaWQgbG9hZF9zcDAoc3RydWN0IHRzc19zdHJ1Y3QgKnRzcywK IAkJCSAgICAgc3RydWN0IHRocmVhZF9zdHJ1Y3QgKnRocmVhZCkKIHsKZGlmZiAtLWdpdCBhL2Fy Y2gveDg2L2luY2x1ZGUvYXNtL3BhcmF2aXJ0X3R5cGVzLmggYi9hcmNoL3g4Ni9pbmNsdWRlL2Fz bS9wYXJhdmlydF90eXBlcy5oCmluZGV4IGU4YzIzMjY0NzhjOC4uNmFjYzFiMjZjZjQwIDEwMDY0 NAotLS0gYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wYXJhdmlydF90eXBlcy5oCisrKyBiL2FyY2gv eDg2L2luY2x1ZGUvYXNtL3BhcmF2aXJ0X3R5cGVzLmgKQEAgLTcwLDE0ICs3MCw5IEBAIHN0cnVj dCBwdl9pbmZvIHsKICNlbmRpZgogCiAJaW50IHBhcmF2aXJ0X2VuYWJsZWQ7Ci0JdW5zaWduZWQg aW50IGZlYXR1cmVzOwkgIC8qIHZhbGlkIG9ubHkgaWYgcGFyYXZpcnRfZW5hYmxlZCBpcyBzZXQg Ki8KIAljb25zdCBjaGFyICpuYW1lOwogfTsKIAotI2RlZmluZSBwYXJhdmlydF9oYXMoeCkgcGFy YXZpcnRfaGFzX2ZlYXR1cmUoUFZfU1VQUE9SVEVEXyMjeCkKLS8qIFN1cHBvcnRlZCBmZWF0dXJl cyAqLwotI2RlZmluZSBQVl9TVVBQT1JURURfUlRDICAgICAgICAoMTw8MCkKLQogc3RydWN0IHB2 X2luaXRfb3BzIHsKIAkvKgogCSAqIFBhdGNoIG1heSByZXBsYWNlIG9uZSBvZiB0aGUgZGVmaW5l ZCBjb2RlIHNlcXVlbmNlcyB3aXRoCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9w cm9jZXNzb3IuaCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL3Byb2Nlc3Nvci5oCmluZGV4IDkyNjQ0 NzZmM2Q1Ny4uMGM3MGM3ZGFhNmI4IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9w cm9jZXNzb3IuaAorKysgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wcm9jZXNzb3IuaApAQCAtNDc0 LDcgKzQ3NCw2IEBAIHN0YXRpYyBpbmxpbmUgdW5zaWduZWQgbG9uZyBjdXJyZW50X3RvcF9vZl9z dGFjayh2b2lkKQogI2Vsc2UKICNkZWZpbmUgX19jcHVpZAkJCW5hdGl2ZV9jcHVpZAogI2RlZmlu ZSBwYXJhdmlydF9lbmFibGVkKCkJMAotI2RlZmluZSBwYXJhdmlydF9oYXMoeCkgCTAKIAogc3Rh dGljIGlubGluZSB2b2lkIGxvYWRfc3AwKHN0cnVjdCB0c3Nfc3RydWN0ICp0c3MsCiAJCQkgICAg c3RydWN0IHRocmVhZF9zdHJ1Y3QgKnRocmVhZCkKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1 ZGUvYXNtL3g4Nl9pbml0LmggYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS94ODZfaW5pdC5oCmluZGV4 IDFhZTg5YTI3MjFkNi4uOGJiOGMxYTQ2MTVhIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9pbmNsdWRl L2FzbS94ODZfaW5pdC5oCisrKyBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL3g4Nl9pbml0LmgKQEAg LTE0Miw2ICsxNDIsMTUgQEAgc3RydWN0IHg4Nl9jcHVpbml0X29wcyB7CiBzdHJ1Y3QgdGltZXNw ZWM7CiAKIC8qKgorICogc3RydWN0IHg4Nl9sZWdhY3lfZmVhdHVyZXMgLSBsZWdhY3kgeDg2IGZl YXR1cmVzCisgKgorICogQHJ0YzogdGhpcyBkZXZpY2UgaGFzIGEgQ01PUyByZWFsLXRpbWUgY2xv Y2sgcHJlc2VudAorICovCitzdHJ1Y3QgeDg2X2xlZ2FjeV9mZWF0dXJlcyB7CisJaW50IHJ0YzsK K307CisKKy8qKgogICogc3RydWN0IHg4Nl9wbGF0Zm9ybV9vcHMgLSBwbGF0Zm9ybSBzcGVjaWZp YyBydW50aW1lIGZ1bmN0aW9ucwogICogQGNhbGlicmF0ZV90c2M6CQljYWxpYnJhdGUgVFNDCiAg KiBAZ2V0X3dhbGxjbG9jazoJCWdldCB0aW1lIGZyb20gSFcgY2xvY2sgbGlrZSBSVEMgZXRjLgpA QCAtMTUyLDYgKzE2MSwxNCBAQCBzdHJ1Y3QgdGltZXNwZWM7CiAgKiBAc2F2ZV9zY2hlZF9jbG9j a19zdGF0ZToJc2F2ZSBzdGF0ZSBmb3Igc2NoZWRfY2xvY2soKSBvbiBzdXNwZW5kCiAgKiBAcmVz dG9yZV9zY2hlZF9jbG9ja19zdGF0ZToJcmVzdG9yZSBzdGF0ZSBmb3Igc2NoZWRfY2xvY2soKSBv biByZXN1bWUKICAqIEBhcGljX3Bvc3RfaW5pdDoJCWFkanVzdCBhcGljIGlmIG5lZWVkZWQKKyAq IEBsZWdhY3k6CQkJbGVnYWN5IGZlYXR1cmVzCisgKiBAc2V0X2xlZ2FjeV9mZWF0dXJlczoJb3Zl cnJpZGUgbGVnYWN5IGZlYXR1cmVzLiBVc2Ugb2YgdGhpcyBjYWxsYmFjaworICogCQkJCWlzIGhp Z2hseSBkaXNjb3VyYWdlZC4gWW91IHNob3VsZCBvbmx5IG5lZWQKKyAqIAkJCQl0aGlzIGlmIHlv dXIgaGFyZHdhcmUgcGxhdGZvcm0gcmVxdWlyZXMgZnVydGhlcgorICogCQkJCWN1c3RvbSBmaW5l IHR1bmluZyBmYXIgYmV5b25nIHdoYXQgbWF5IGJlCisgKiAJCQkJcG9zc2libGUgaW4geDg2X2Vh cmx5X2luaXRfcGxhdGZvcm1fcXVpcmtzKCkgYnkKKyAqIAkJCQlvbmx5IHVzaW5nIHRoZSBjdXJy ZW50IHg4Nl9oYXJkd2FyZV9zdWJhcmNoCisgKiAJCQkJc2VtYW50aWNzLgogICovCiBzdHJ1Y3Qg eDg2X3BsYXRmb3JtX29wcyB7CiAJdW5zaWduZWQgbG9uZyAoKmNhbGlicmF0ZV90c2MpKHZvaWQp OwpAQCAtMTY1LDYgKzE4Miw4IEBAIHN0cnVjdCB4ODZfcGxhdGZvcm1fb3BzIHsKIAl2b2lkICgq c2F2ZV9zY2hlZF9jbG9ja19zdGF0ZSkodm9pZCk7CiAJdm9pZCAoKnJlc3RvcmVfc2NoZWRfY2xv Y2tfc3RhdGUpKHZvaWQpOwogCXZvaWQgKCphcGljX3Bvc3RfaW5pdCkodm9pZCk7CisJc3RydWN0 IHg4Nl9sZWdhY3lfZmVhdHVyZXMgbGVnYWN5OworCXZvaWQgKCpzZXRfbGVnYWN5X2ZlYXR1cmVz KSh2b2lkKTsKIH07CiAKIHN0cnVjdCBwY2lfZGV2OwpAQCAtMTg2LDYgKzIwNSw4IEBAIGV4dGVy biBzdHJ1Y3QgeDg2X2NwdWluaXRfb3BzIHg4Nl9jcHVpbml0OwogZXh0ZXJuIHN0cnVjdCB4ODZf cGxhdGZvcm1fb3BzIHg4Nl9wbGF0Zm9ybTsKIGV4dGVybiBzdHJ1Y3QgeDg2X21zaV9vcHMgeDg2 X21zaTsKIGV4dGVybiBzdHJ1Y3QgeDg2X2lvX2FwaWNfb3BzIHg4Nl9pb19hcGljX29wczsKKwor ZXh0ZXJuIHZvaWQgeDg2X2Vhcmx5X2luaXRfcGxhdGZvcm1fcXVpcmtzKHZvaWQpOwogZXh0ZXJu IHZvaWQgeDg2X2luaXRfbm9vcCh2b2lkKTsKIGV4dGVybiB2b2lkIHg4Nl9pbml0X3VpbnRfbm9v cCh1bnNpZ25lZCBpbnQgdW51c2VkKTsKIApkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL01h a2VmaWxlIGIvYXJjaC94ODYva2VybmVsL01ha2VmaWxlCmluZGV4IDg5ZjhhZGUwYmM3Yy4uN2E5 ZTQ0ZDkzNWRlIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvTWFrZWZpbGUKKysrIGIvYXJj aC94ODYva2VybmVsL01ha2VmaWxlCkBAIC0yLDcgKzIsMTEgQEAKICMgTWFrZWZpbGUgZm9yIHRo ZSBsaW51eCBrZXJuZWwuCiAjCiAKLWV4dHJhLXkgICAgICAgICAgICAgICAgOj0gaGVhZF8kKEJJ VFMpLm8gaGVhZCQoQklUUykubyBoZWFkLm8gdm1saW51eC5sZHMKK2V4dHJhLXkJOj0gaGVhZF8k KEJJVFMpLm8KK2V4dHJhLXkJKz0gaGVhZCQoQklUUykubworZXh0cmEteQkrPSBoZWFkLm8KK2V4 dHJhLXkJKz0gcGxhdGZvcm0tcXVpcmtzLm8KK2V4dHJhLXkJKz0gdm1saW51eC5sZHMKIAogQ1BQ RkxBR1Nfdm1saW51eC5sZHMgKz0gLVUkKFVUU19NQUNISU5FKQogCmRpZmYgLS1naXQgYS9hcmNo L3g4Ni9rZXJuZWwvaGVhZDMyLmMgYi9hcmNoL3g4Ni9rZXJuZWwvaGVhZDMyLmMKaW5kZXggMjkx MWVmM2E5ZjFjLi5kNzg0YmI1NDdhOWQgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2tlcm5lbC9oZWFk MzIuYworKysgYi9hcmNoL3g4Ni9rZXJuZWwvaGVhZDMyLmMKQEAgLTM0LDYgKzM0LDggQEAgYXNt bGlua2FnZSBfX3Zpc2libGUgdm9pZCBfX2luaXQgaTM4Nl9zdGFydF9rZXJuZWwodm9pZCkKIAlj cjRfaW5pdF9zaGFkb3coKTsKIAlzYW5pdGl6ZV9ib290X3BhcmFtcygmYm9vdF9wYXJhbXMpOwog CisJeDg2X2Vhcmx5X2luaXRfcGxhdGZvcm1fcXVpcmtzKCk7CisKIAkvKiBDYWxsIHRoZSBzdWJh cmNoIHNwZWNpZmljIGVhcmx5IHNldHVwIGZ1bmN0aW9uICovCiAJc3dpdGNoIChib290X3BhcmFt cy5oZHIuaGFyZHdhcmVfc3ViYXJjaCkgewogCWNhc2UgWDg2X1NVQkFSQ0hfSU5URUxfTUlEOgpk aWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL2hlYWQ2NC5jIGIvYXJjaC94ODYva2VybmVsL2hl YWQ2NC5jCmluZGV4IDFmNDQyMmQ1YzhkMC4uYjcyZmIwYjcxZGQxIDEwMDY0NAotLS0gYS9hcmNo L3g4Ni9rZXJuZWwvaGVhZDY0LmMKKysrIGIvYXJjaC94ODYva2VybmVsL2hlYWQ2NC5jCkBAIC0x ODIsNiArMTgyLDcgQEAgdm9pZCBfX2luaXQgeDg2XzY0X3N0YXJ0X3Jlc2VydmF0aW9ucyhjaGFy ICpyZWFsX21vZGVfZGF0YSkKIAlpZiAoIWJvb3RfcGFyYW1zLmhkci52ZXJzaW9uKQogCQljb3B5 X2Jvb3RkYXRhKF9fdmEocmVhbF9tb2RlX2RhdGEpKTsKIAorCXg4Nl9lYXJseV9pbml0X3BsYXRm b3JtX3F1aXJrcygpOwogCXJlc2VydmVfZWJkYV9yZWdpb24oKTsKIAogCXN3aXRjaCAoYm9vdF9w YXJhbXMuaGRyLmhhcmR3YXJlX3N1YmFyY2gpIHsKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5l bC9wbGF0Zm9ybS1xdWlya3MuYyBiL2FyY2gveDg2L2tlcm5lbC9wbGF0Zm9ybS1xdWlya3MuYwpu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjAyMWE1Zjk3M2NlMwotLS0g L2Rldi9udWxsCisrKyBiL2FyY2gveDg2L2tlcm5lbC9wbGF0Zm9ybS1xdWlya3MuYwpAQCAtMCww ICsxLDIxIEBACisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvaW5p dC5oPgorCisjaW5jbHVkZSA8YXNtL3NldHVwLmg+CisjaW5jbHVkZSA8YXNtL2Jpb3NfZWJkYS5o PgorCit2b2lkIF9faW5pdCB4ODZfZWFybHlfaW5pdF9wbGF0Zm9ybV9xdWlya3Modm9pZCkKK3sK Kwl4ODZfcGxhdGZvcm0ubGVnYWN5LnJ0YyA9IDE7CisKKwlzd2l0Y2ggKGJvb3RfcGFyYW1zLmhk ci5oYXJkd2FyZV9zdWJhcmNoKSB7CisJY2FzZSBYODZfU1VCQVJDSF9YRU46CisJY2FzZSBYODZf U1VCQVJDSF9MR1VFU1Q6CisJY2FzZSBYODZfU1VCQVJDSF9JTlRFTF9NSUQ6CisJCXg4Nl9wbGF0 Zm9ybS5sZWdhY3kucnRjID0gMDsKKwkJYnJlYWs7CisJfQorCisJaWYgKHg4Nl9wbGF0Zm9ybS5z ZXRfbGVnYWN5X2ZlYXR1cmVzKQorCQl4ODZfcGxhdGZvcm0uc2V0X2xlZ2FjeV9mZWF0dXJlcygp OworfQpkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL3J0Yy5jIGIvYXJjaC94ODYva2VybmVs L3J0Yy5jCmluZGV4IDRhZjhkMDYzZmIzNi4uNjJjNDhkYTM4ODlkIDEwMDY0NAotLS0gYS9hcmNo L3g4Ni9rZXJuZWwvcnRjLmMKKysrIGIvYXJjaC94ODYva2VybmVsL3J0Yy5jCkBAIC0xNCw2ICsx NCw3IEBACiAjaW5jbHVkZSA8YXNtL3RpbWUuaD4KICNpbmNsdWRlIDxhc20vaW50ZWwtbWlkLmg+ CiAjaW5jbHVkZSA8YXNtL3J0Yy5oPgorI2luY2x1ZGUgPGFzbS9zZXR1cC5oPgogCiAjaWZkZWYg Q09ORklHX1g4Nl8zMgogLyoKQEAgLTE4OCwxMCArMTg5LDYgQEAgc3RhdGljIF9faW5pdCBpbnQg YWRkX3J0Y19jbW9zKHZvaWQpCiAJaWYgKG9mX2hhdmVfcG9wdWxhdGVkX2R0KCkpCiAJCXJldHVy biAwOwogCi0JLyogSW50ZWwgTUlEIHBsYXRmb3JtcyBkb24ndCBoYXZlIGlvcG9ydCBydGMgKi8K LQlpZiAoaW50ZWxfbWlkX2lkZW50aWZ5X2NwdSgpKQotCQlyZXR1cm4gLUVOT0RFVjsKLQogI2lm ZGVmIENPTkZJR19BQ1BJCiAJaWYgKGFjcGlfZ2JsX0ZBRFQuYm9vdF9mbGFncyAmIEFDUElfRkFE VF9OT19DTU9TX1JUQykgewogCQkvKiBUaGlzIHdhcm5pbmcgY2FuIGxpa2VseSBnbyBhd2F5IGFn YWluIGluIGEgeWVhciBvciB0d28uICovCkBAIC0yMDAsNyArMTk3LDcgQEAgc3RhdGljIF9faW5p dCBpbnQgYWRkX3J0Y19jbW9zKHZvaWQpCiAJfQogI2VuZGlmCiAKLQlpZiAocGFyYXZpcnRfZW5h YmxlZCgpICYmICFwYXJhdmlydF9oYXMoUlRDKSkKKwlpZiAoIXg4Nl9wbGF0Zm9ybS5sZWdhY3ku cnRjKQogCQlyZXR1cm4gLUVOT0RFVjsKIAogCXBsYXRmb3JtX2RldmljZV9yZWdpc3RlcigmcnRj X2RldmljZSk7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9sZ3Vlc3QvYm9vdC5jIGIvYXJjaC94ODYv bGd1ZXN0L2Jvb3QuYwppbmRleCBmZDU3ZDNhZTdlMTYuLmY1NDk3ZWU1ZmQyZiAxMDA2NDQKLS0t IGEvYXJjaC94ODYvbGd1ZXN0L2Jvb3QuYworKysgYi9hcmNoL3g4Ni9sZ3Vlc3QvYm9vdC5jCkBA IC0xNDE0LDcgKzE0MTQsNiBAQCBfX2luaXQgdm9pZCBsZ3Vlc3RfaW5pdCh2b2lkKQogCXB2X2lu Zm8ua2VybmVsX3JwbCA9IDE7CiAJLyogRXZlcnlvbmUgZXhjZXB0IFhlbiBydW5zIHdpdGggdGhp cyBzZXQuICovCiAJcHZfaW5mby5zaGFyZWRfa2VybmVsX3BtZCA9IDE7Ci0JcHZfaW5mby5mZWF0 dXJlcyA9IDA7CiAKIAkvKgogCSAqIFdlIHNldCB1cCBhbGwgdGhlIGxndWVzdCBvdmVycmlkZXMg Zm9yIHNlbnNpdGl2ZSBvcGVyYXRpb25zLiAgVGhlc2UKZGlmZiAtLWdpdCBhL2FyY2gveDg2L3hl bi9lbmxpZ2h0ZW4uYyBiL2FyY2gveDg2L3hlbi9lbmxpZ2h0ZW4uYwppbmRleCA0MDQ4N2YxZWNi NGMuLmIwODQ4OWJhNTA1MSAxMDA2NDQKLS0tIGEvYXJjaC94ODYveGVuL2VubGlnaHRlbi5jCisr KyBiL2FyY2gveDg2L3hlbi9lbmxpZ2h0ZW4uYwpAQCAtMTE5Miw3ICsxMTkyLDYgQEAgc3RhdGlj IGNvbnN0IHN0cnVjdCBwdl9pbmZvIHhlbl9pbmZvIF9faW5pdGNvbnN0ID0gewogI2lmZGVmIENP TkZJR19YODZfNjQKIAkuZXh0cmFfdXNlcl82NGJpdF9jcyA9IEZMQVRfVVNFUl9DUzY0LAogI2Vu ZGlmCi0JLmZlYXR1cmVzID0gMCwKIAkubmFtZSA9ICJYZW4iLAogfTsKIApAQCAtMTUwNSw2ICsx NTA0LDExIEBAIHN0YXRpYyB2b2lkIF9faW5pdCB4ZW5fcHZoX2Vhcmx5X2d1ZXN0X2luaXQodm9p ZCkKIH0KICNlbmRpZiAgICAvKiBDT05GSUdfWEVOX1BWSCAqLwogCitzdGF0aWMgdm9pZCBfX2lu aXQgeGVuX2RvbTBfc2V0X2xlZ2FjeV9mZWF0dXJlcyh2b2lkKQoreworCXg4Nl9wbGF0Zm9ybS5s ZWdhY3kucnRjID0gMTsKK30KKwogLyogRmlyc3QgQyBmdW5jdGlvbiB0byBiZSBjYWxsZWQgb24g WGVuIGJvb3QgKi8KIGFzbWxpbmthZ2UgX192aXNpYmxlIHZvaWQgX19pbml0IHhlbl9zdGFydF9r ZXJuZWwodm9pZCkKIHsKQEAgLTE1MjUsOCArMTUyOSw2IEBAIGFzbWxpbmthZ2UgX192aXNpYmxl IHZvaWQgX19pbml0IHhlbl9zdGFydF9rZXJuZWwodm9pZCkKIAogCS8qIEluc3RhbGwgWGVuIHBh cmF2aXJ0IG9wcyAqLwogCXB2X2luZm8gPSB4ZW5faW5mbzsKLQlpZiAoeGVuX2luaXRpYWxfZG9t YWluKCkpCi0JCXB2X2luZm8uZmVhdHVyZXMgfD0gUFZfU1VQUE9SVEVEX1JUQzsKIAlwdl9pbml0 X29wcyA9IHhlbl9pbml0X29wczsKIAlpZiAoIXhlbl9wdmhfZG9tYWluKCkpIHsKIAkJcHZfY3B1 X29wcyA9IHhlbl9jcHVfb3BzOwpAQCAtMTY3OSw2ICsxNjgxLDggQEAgYXNtbGlua2FnZSBfX3Zp c2libGUgdm9pZCBfX2luaXQgeGVuX3N0YXJ0X2tlcm5lbCh2b2lkKQogCQkJLnUuZmlybXdhcmVf aW5mby50eXBlID0gWEVOX0ZXX0tCRF9TSElGVF9GTEFHUywKIAkJfTsKIAorCQl4ODZfcGxhdGZv cm0uc2V0X2xlZ2FjeV9mZWF0dXJlcyA9CisJCQkJeGVuX2RvbTBfc2V0X2xlZ2FjeV9mZWF0dXJl czsKIAkJeGVuX2luaXRfdmdhKGluZm8sIHhlbl9zdGFydF9pbmZvLT5jb25zb2xlLmRvbTAuaW5m b19zaXplKTsKIAkJeGVuX3N0YXJ0X2luZm8tPmNvbnNvbGUuZG9tVS5tZm4gPSAwOwogCQl4ZW5f c3RhcnRfaW5mby0+Y29uc29sZS5kb21VLmV2dGNobiA9IDA7Ci0tIAoyLjcuMgoKCl9fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClhlbi1kZXZlbCBtYWlsaW5n IGxpc3QKWGVuLWRldmVsQGxpc3RzLnhlbi5vcmcKaHR0cDovL2xpc3RzLnhlbi5vcmcveGVuLWRl dmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755369AbcDNAI7 (ORCPT ); Wed, 13 Apr 2016 20:08:59 -0400 Received: from mail.kernel.org ([198.145.29.136]:36472 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932282AbcDNAFD (ORCPT ); Wed, 13 Apr 2016 20:05:03 -0400 From: "Luis R. Rodriguez" To: bp@alien8.de, hpa@zytor.com, tglx@linutronix.de, mingo@redhat.com, rusty@rustcorp.com.au Cc: x86@kernel.org, linux-kernel@vger.kernel.org, luto@amacapital.net, boris.ostrovsky@oracle.com, jgross@suse.com, david.vrabel@citrix.com, konrad.wilk@oracle.com, xen-devel@lists.xensource.com, lguest@lists.ozlabs.org, andriy.shevchenko@linux.intel.com, jlee@suse.com, glin@suse.com, matt@codeblueprint.co.uk, andrew.cooper3@citrix.com, rjw@rjwysocki.net, lenb@kernel.org, robert.moore@intel.com, lv.zheng@intel.com, toshi.kani@hp.com, linux-acpi@vger.kernel.org, kozerkov@parallels.com, josh@joshtriplett.org, bigeasy@linutronix.de, ffainelli@freebox.fr, george.dunlap@citrix.com, julien.grall@linaro.org, mbizon@freebox.fr, tiwai@suse.de, "Luis R. Rodriguez" Subject: [PATCH v6 04/16] x86/rtc: replace paravirt rtc check with platform legacy quirk Date: Wed, 13 Apr 2016 17:04:34 -0700 Message-Id: <1460592286-300-5-git-send-email-mcgrof@kernel.org> X-Mailer: git-send-email 2.7.0 In-Reply-To: <1460592286-300-1-git-send-email-mcgrof@kernel.org> References: <1460592286-300-1-git-send-email-mcgrof@kernel.org> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org We have 4 types of x86 platforms that disable RTC: * Intel MID * Lguest - uses paravirt * Xen dom-U - uses paravirt * x86 on legacy systems annotated with an ACPI legacy flag We can consolidate all of these into a platform specific legacy quirk set early in boot through i386_start_kernel() and through x86_64_start_reservations(). This deals with the RTC quirks which we can rely on through the hardware subarch, the ACPI check can be dealt with separately. For Xen things are bit more complex given that the @X86_SUBARCH_XEN x86_hardware_subarch is shared on for Xen which uses the PV path for both domU and dom0. Since the semantics for differentiating between the two are Xen specific we provide a platform helper to help override default legacy features -- x86_platform.set_legacy_features(). Use of this helper is highly discouraged, its only purpose should be to account for the lack of semantics available within your given x86_hardware_subarch. As per 0-day, this bumps the vmlinux size using i386-tinyconfig as follows: TOTAL TEXT init.text x86_early_init_platform_quirks() +70 +62 +62 +43 Only 8 bytes overhead total, as the main increase in size is all removed via __init. v4: split the subarch check from the ACPI check, clarify on the ACPI change commit log why ordering works v5: add x86_platform.set_legacy_features() to account for dom0, add also size impact on vmlinux as per 0-day report v6: Use __init on xen_dom0_set_legacy_features() Suggested-by: Ingo Molnar Signed-off-by: Luis R. Rodriguez --- arch/x86/Makefile | 1 + arch/x86/include/asm/paravirt.h | 6 ------ arch/x86/include/asm/paravirt_types.h | 5 ----- arch/x86/include/asm/processor.h | 1 - arch/x86/include/asm/x86_init.h | 21 +++++++++++++++++++++ arch/x86/kernel/Makefile | 6 +++++- arch/x86/kernel/head32.c | 2 ++ arch/x86/kernel/head64.c | 1 + arch/x86/kernel/platform-quirks.c | 21 +++++++++++++++++++++ arch/x86/kernel/rtc.c | 7 ++----- arch/x86/lguest/boot.c | 1 - arch/x86/xen/enlighten.c | 10 +++++++--- 12 files changed, 60 insertions(+), 22 deletions(-) create mode 100644 arch/x86/kernel/platform-quirks.c diff --git a/arch/x86/Makefile b/arch/x86/Makefile index 4086abca0b32..f9ed8a7ce2b6 100644 --- a/arch/x86/Makefile +++ b/arch/x86/Makefile @@ -209,6 +209,7 @@ endif head-y := arch/x86/kernel/head_$(BITS).o head-y += arch/x86/kernel/head$(BITS).o head-y += arch/x86/kernel/head.o +head-y += arch/x86/kernel/platform-quirks.o libs-y += arch/x86/lib/ diff --git a/arch/x86/include/asm/paravirt.h b/arch/x86/include/asm/paravirt.h index 601f1b8f9961..6c7a4a192032 100644 --- a/arch/x86/include/asm/paravirt.h +++ b/arch/x86/include/asm/paravirt.h @@ -20,12 +20,6 @@ static inline int paravirt_enabled(void) return pv_info.paravirt_enabled; } -static inline int paravirt_has_feature(unsigned int feature) -{ - WARN_ON_ONCE(!pv_info.paravirt_enabled); - return (pv_info.features & feature); -} - static inline void load_sp0(struct tss_struct *tss, struct thread_struct *thread) { diff --git a/arch/x86/include/asm/paravirt_types.h b/arch/x86/include/asm/paravirt_types.h index e8c2326478c8..6acc1b26cf40 100644 --- a/arch/x86/include/asm/paravirt_types.h +++ b/arch/x86/include/asm/paravirt_types.h @@ -70,14 +70,9 @@ struct pv_info { #endif int paravirt_enabled; - unsigned int features; /* valid only if paravirt_enabled is set */ const char *name; }; -#define paravirt_has(x) paravirt_has_feature(PV_SUPPORTED_##x) -/* Supported features */ -#define PV_SUPPORTED_RTC (1<<0) - struct pv_init_ops { /* * Patch may replace one of the defined code sequences with diff --git a/arch/x86/include/asm/processor.h b/arch/x86/include/asm/processor.h index 9264476f3d57..0c70c7daa6b8 100644 --- a/arch/x86/include/asm/processor.h +++ b/arch/x86/include/asm/processor.h @@ -474,7 +474,6 @@ static inline unsigned long current_top_of_stack(void) #else #define __cpuid native_cpuid #define paravirt_enabled() 0 -#define paravirt_has(x) 0 static inline void load_sp0(struct tss_struct *tss, struct thread_struct *thread) diff --git a/arch/x86/include/asm/x86_init.h b/arch/x86/include/asm/x86_init.h index 1ae89a2721d6..8bb8c1a4615a 100644 --- a/arch/x86/include/asm/x86_init.h +++ b/arch/x86/include/asm/x86_init.h @@ -142,6 +142,15 @@ struct x86_cpuinit_ops { struct timespec; /** + * struct x86_legacy_features - legacy x86 features + * + * @rtc: this device has a CMOS real-time clock present + */ +struct x86_legacy_features { + int rtc; +}; + +/** * struct x86_platform_ops - platform specific runtime functions * @calibrate_tsc: calibrate TSC * @get_wallclock: get time from HW clock like RTC etc. @@ -152,6 +161,14 @@ struct timespec; * @save_sched_clock_state: save state for sched_clock() on suspend * @restore_sched_clock_state: restore state for sched_clock() on resume * @apic_post_init: adjust apic if neeeded + * @legacy: legacy features + * @set_legacy_features: override legacy features. Use of this callback + * is highly discouraged. You should only need + * this if your hardware platform requires further + * custom fine tuning far beyong what may be + * possible in x86_early_init_platform_quirks() by + * only using the current x86_hardware_subarch + * semantics. */ struct x86_platform_ops { unsigned long (*calibrate_tsc)(void); @@ -165,6 +182,8 @@ struct x86_platform_ops { void (*save_sched_clock_state)(void); void (*restore_sched_clock_state)(void); void (*apic_post_init)(void); + struct x86_legacy_features legacy; + void (*set_legacy_features)(void); }; struct pci_dev; @@ -186,6 +205,8 @@ extern struct x86_cpuinit_ops x86_cpuinit; extern struct x86_platform_ops x86_platform; extern struct x86_msi_ops x86_msi; extern struct x86_io_apic_ops x86_io_apic_ops; + +extern void x86_early_init_platform_quirks(void); extern void x86_init_noop(void); extern void x86_init_uint_noop(unsigned int unused); diff --git a/arch/x86/kernel/Makefile b/arch/x86/kernel/Makefile index 89f8ade0bc7c..7a9e44d935de 100644 --- a/arch/x86/kernel/Makefile +++ b/arch/x86/kernel/Makefile @@ -2,7 +2,11 @@ # Makefile for the linux kernel. # -extra-y := head_$(BITS).o head$(BITS).o head.o vmlinux.lds +extra-y := head_$(BITS).o +extra-y += head$(BITS).o +extra-y += head.o +extra-y += platform-quirks.o +extra-y += vmlinux.lds CPPFLAGS_vmlinux.lds += -U$(UTS_MACHINE) diff --git a/arch/x86/kernel/head32.c b/arch/x86/kernel/head32.c index 2911ef3a9f1c..d784bb547a9d 100644 --- a/arch/x86/kernel/head32.c +++ b/arch/x86/kernel/head32.c @@ -34,6 +34,8 @@ asmlinkage __visible void __init i386_start_kernel(void) cr4_init_shadow(); sanitize_boot_params(&boot_params); + x86_early_init_platform_quirks(); + /* Call the subarch specific early setup function */ switch (boot_params.hdr.hardware_subarch) { case X86_SUBARCH_INTEL_MID: diff --git a/arch/x86/kernel/head64.c b/arch/x86/kernel/head64.c index 1f4422d5c8d0..b72fb0b71dd1 100644 --- a/arch/x86/kernel/head64.c +++ b/arch/x86/kernel/head64.c @@ -182,6 +182,7 @@ void __init x86_64_start_reservations(char *real_mode_data) if (!boot_params.hdr.version) copy_bootdata(__va(real_mode_data)); + x86_early_init_platform_quirks(); reserve_ebda_region(); switch (boot_params.hdr.hardware_subarch) { diff --git a/arch/x86/kernel/platform-quirks.c b/arch/x86/kernel/platform-quirks.c new file mode 100644 index 000000000000..021a5f973ce3 --- /dev/null +++ b/arch/x86/kernel/platform-quirks.c @@ -0,0 +1,21 @@ +#include +#include + +#include +#include + +void __init x86_early_init_platform_quirks(void) +{ + x86_platform.legacy.rtc = 1; + + switch (boot_params.hdr.hardware_subarch) { + case X86_SUBARCH_XEN: + case X86_SUBARCH_LGUEST: + case X86_SUBARCH_INTEL_MID: + x86_platform.legacy.rtc = 0; + break; + } + + if (x86_platform.set_legacy_features) + x86_platform.set_legacy_features(); +} diff --git a/arch/x86/kernel/rtc.c b/arch/x86/kernel/rtc.c index 4af8d063fb36..62c48da3889d 100644 --- a/arch/x86/kernel/rtc.c +++ b/arch/x86/kernel/rtc.c @@ -14,6 +14,7 @@ #include #include #include +#include #ifdef CONFIG_X86_32 /* @@ -188,10 +189,6 @@ static __init int add_rtc_cmos(void) if (of_have_populated_dt()) return 0; - /* Intel MID platforms don't have ioport rtc */ - if (intel_mid_identify_cpu()) - return -ENODEV; - #ifdef CONFIG_ACPI if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_CMOS_RTC) { /* This warning can likely go away again in a year or two. */ @@ -200,7 +197,7 @@ static __init int add_rtc_cmos(void) } #endif - if (paravirt_enabled() && !paravirt_has(RTC)) + if (!x86_platform.legacy.rtc) return -ENODEV; platform_device_register(&rtc_device); diff --git a/arch/x86/lguest/boot.c b/arch/x86/lguest/boot.c index fd57d3ae7e16..f5497ee5fd2f 100644 --- a/arch/x86/lguest/boot.c +++ b/arch/x86/lguest/boot.c @@ -1414,7 +1414,6 @@ __init void lguest_init(void) pv_info.kernel_rpl = 1; /* Everyone except Xen runs with this set. */ pv_info.shared_kernel_pmd = 1; - pv_info.features = 0; /* * We set up all the lguest overrides for sensitive operations. These diff --git a/arch/x86/xen/enlighten.c b/arch/x86/xen/enlighten.c index 40487f1ecb4c..b08489ba5051 100644 --- a/arch/x86/xen/enlighten.c +++ b/arch/x86/xen/enlighten.c @@ -1192,7 +1192,6 @@ static const struct pv_info xen_info __initconst = { #ifdef CONFIG_X86_64 .extra_user_64bit_cs = FLAT_USER_CS64, #endif - .features = 0, .name = "Xen", }; @@ -1505,6 +1504,11 @@ static void __init xen_pvh_early_guest_init(void) } #endif /* CONFIG_XEN_PVH */ +static void __init xen_dom0_set_legacy_features(void) +{ + x86_platform.legacy.rtc = 1; +} + /* First C function to be called on Xen boot */ asmlinkage __visible void __init xen_start_kernel(void) { @@ -1525,8 +1529,6 @@ asmlinkage __visible void __init xen_start_kernel(void) /* Install Xen paravirt ops */ pv_info = xen_info; - if (xen_initial_domain()) - pv_info.features |= PV_SUPPORTED_RTC; pv_init_ops = xen_init_ops; if (!xen_pvh_domain()) { pv_cpu_ops = xen_cpu_ops; @@ -1679,6 +1681,8 @@ asmlinkage __visible void __init xen_start_kernel(void) .u.firmware_info.type = XEN_FW_KBD_SHIFT_FLAGS, }; + x86_platform.set_legacy_features = + xen_dom0_set_legacy_features; xen_init_vga(info, xen_start_info->console.dom0.info_size); xen_start_info->console.domU.mfn = 0; xen_start_info->console.domU.evtchn = 0; -- 2.7.2