From mboxrd@z Thu Jan 1 00:00:00 1970 From: linus.walleij@linaro.org (Linus Walleij) Date: Wed, 18 Apr 2018 10:52:41 +0200 Subject: [PATCH 1/2 v3] drm/pl111: Support the Versatile Express Message-ID: <20180418085242.19525-1-linus.walleij@linaro.org> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org The Versatile Express uses a special configuration controller deeply embedded in the system motherboard FPGA to multiplex the two to three (!) display controller instances out to the single SiI9022 bridge. Set up an extra file with the logic to probe to the FPGA mux register on the system controller bus, then parse the device tree to see if there is a CLCD or HDLCD instance on the core tile (also known as the daughterboard) by looking in the root of the device tree for compatible nodes. - If there is a HDLCD on the core tile, and there is a driver for it, we exit probe and deactivate the motherboard CLCD. We do not touch the DVI mux in this case, to make sure we don't break HDLCD. - If there is a CLCD on both the motherboard and the core tile (only the CA9 has this) the core tile CLCD takes precedence and get muxed to the DVI connector. - Only if there is no working graphics on the core tile, the motherboard CLCD is probed and muxed to the DVI connector. Core tile graphics should always take precedence as it can address all memory and is also faster, however the motherboard CLCD is good to have around for diagnostics and testing. It is possible to test the motherboard CLCD by setting the status = "disabled" property on the core tile CLCD or HDLCD. Scale down the Versatile Express to 16BPP so we can support a 1024x768 display despite the bus bandwidth restrictions on this platform. (The motherboard CLCD supports slightly lower resolution.) Cc: Liviu Dudau Cc: Pawel Moll Signed-off-by: Linus Walleij --- ChangeLog v2->v3: - Rewrite CLCD detection and mux priority logic, look in the device tree root for core tile graphics. ChangeLog v1->v2: - No changes just reposting rebased on mainline changes. --- drivers/gpu/drm/pl111/Makefile | 1 + drivers/gpu/drm/pl111/pl111_versatile.c | 48 +++++++++++- drivers/gpu/drm/pl111/pl111_vexpress.c | 127 ++++++++++++++++++++++++++++++++ drivers/gpu/drm/pl111/pl111_vexpress.h | 22 ++++++ 4 files changed, 197 insertions(+), 1 deletion(-) create mode 100644 drivers/gpu/drm/pl111/pl111_vexpress.c create mode 100644 drivers/gpu/drm/pl111/pl111_vexpress.h diff --git a/drivers/gpu/drm/pl111/Makefile b/drivers/gpu/drm/pl111/Makefile index 9c5e8dba8ac6..19a8189dc54f 100644 --- a/drivers/gpu/drm/pl111/Makefile +++ b/drivers/gpu/drm/pl111/Makefile @@ -3,6 +3,7 @@ pl111_drm-y += pl111_display.o \ pl111_versatile.o \ pl111_drv.o +pl111_drm-$(CONFIG_ARCH_VEXPRESS) += pl111_vexpress.o pl111_drm-$(CONFIG_DEBUG_FS) += pl111_debugfs.o obj-$(CONFIG_DRM_PL111) += pl111_drm.o diff --git a/drivers/gpu/drm/pl111/pl111_versatile.c b/drivers/gpu/drm/pl111/pl111_versatile.c index 9302f516045e..569edf02a36a 100644 --- a/drivers/gpu/drm/pl111/pl111_versatile.c +++ b/drivers/gpu/drm/pl111/pl111_versatile.c @@ -1,12 +1,14 @@ #include #include #include +#include #include #include #include #include #include #include "pl111_versatile.h" +#include "pl111_vexpress.h" #include "pl111_drm.h" static struct regmap *versatile_syscon_map; @@ -22,6 +24,7 @@ enum versatile_clcd { REALVIEW_CLCD_PB11MP, REALVIEW_CLCD_PBA8, REALVIEW_CLCD_PBX, + VEXPRESS_CLCD_V2M, }; static const struct of_device_id versatile_clcd_of_match[] = { @@ -53,6 +56,10 @@ static const struct of_device_id versatile_clcd_of_match[] = { .compatible = "arm,realview-pbx-syscon", .data = (void *)REALVIEW_CLCD_PBX, }, + { + .compatible = "arm,vexpress-muxfpga", + .data = (void *)VEXPRESS_CLCD_V2M, + }, {}, }; @@ -286,12 +293,26 @@ static const struct pl111_variant_data pl111_realview = { .fb_bpp = 16, }; +/* + * Versatile Express PL111 variant, again we just push the maximum + * BPP to 16 to be able to get 1024x768 without saturating the memory + * bus. The clockdivider also seems broken on the Versatile Express. + */ +static const struct pl111_variant_data pl111_vexpress = { + .name = "PL111 Versatile Express", + .formats = pl111_realview_pixel_formats, + .nformats = ARRAY_SIZE(pl111_realview_pixel_formats), + .fb_bpp = 16, + .broken_clockdivider = true, +}; + int pl111_versatile_init(struct device *dev, struct pl111_drm_dev_private *priv) { const struct of_device_id *clcd_id; enum versatile_clcd versatile_clcd_type; struct device_node *np; struct regmap *map; + int ret; np = of_find_matching_node_and_match(NULL, versatile_clcd_of_match, &clcd_id); @@ -301,7 +322,25 @@ int pl111_versatile_init(struct device *dev, struct pl111_drm_dev_private *priv) } versatile_clcd_type = (enum versatile_clcd)clcd_id->data; - map = syscon_node_to_regmap(np); + /* Versatile Express special handling */ + if (versatile_clcd_type == VEXPRESS_CLCD_V2M) { + struct platform_device *pdev; + + /* Call into deep Vexpress configuration API */ + pdev = of_find_device_by_node(np); + if (!pdev) { + dev_err(dev, "can't find the sysreg device, deferring\n"); + return -EPROBE_DEFER; + } + map = dev_get_drvdata(&pdev->dev); + if (!map) { + dev_err(dev, "sysreg has not yet probed\n"); + return -EPROBE_DEFER; + } + } else { + map = syscon_node_to_regmap(np); + } + if (IS_ERR(map)) { dev_err(dev, "no Versatile syscon regmap\n"); return PTR_ERR(map); @@ -340,6 +379,13 @@ int pl111_versatile_init(struct device *dev, struct pl111_drm_dev_private *priv) priv->variant_display_disable = pl111_realview_clcd_disable; dev_info(dev, "set up callbacks for RealView PL111\n"); break; + case VEXPRESS_CLCD_V2M: + priv->variant = &pl111_vexpress; + dev_info(dev, "initializing Versatile Express PL111\n"); + ret = pl111_vexpress_clcd_init(dev, priv, map); + if (ret) + return ret; + break; default: dev_info(dev, "unknown Versatile system controller\n"); break; diff --git a/drivers/gpu/drm/pl111/pl111_vexpress.c b/drivers/gpu/drm/pl111/pl111_vexpress.c new file mode 100644 index 000000000000..56908027659f --- /dev/null +++ b/drivers/gpu/drm/pl111/pl111_vexpress.c @@ -0,0 +1,127 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Versatile Express PL111 handling + * Copyright (C) 2018 Linus Walleij + * + * This module binds to the "arm,vexpress-muxfpga" device on the + * Versatile Express configuration bus and sets up which CLCD instance + * gets muxed out on the DVI bridge. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include "pl111_drm.h" +#include "pl111_vexpress.h" + +#define VEXPRESS_FPGAMUX_MOTHERBOARD 0x00 +#define VEXPRESS_FPGAMUX_DAUGHTERBOARD_1 0x01 +#define VEXPRESS_FPGAMUX_DAUGHTERBOARD_2 0x02 + +int pl111_vexpress_clcd_init(struct device *dev, + struct pl111_drm_dev_private *priv, + struct regmap *map) +{ + struct device_node *root; + struct device_node *child; + struct device_node *ct_clcd = NULL; + bool has_coretile_clcd = false; + bool has_coretile_hdlcd = false; + bool mux_motherboard = true; + u32 val; + int ret; + + /* + * Check if we have a CLCD or HDLCD on the core tile by checking if a + * CLCD or HDLCD is available in the root of the device tree. + */ + root = of_find_node_by_path("/"); + if (!root) + return -EINVAL; + + for_each_child_of_node(root, child) { + if (of_device_is_compatible(child, "arm,pl111") + && of_device_is_available(child)) { + has_coretile_clcd = true; + ct_clcd = child; + break; + } + if (of_device_is_compatible(child, "arm,hdlcd") + && of_device_is_available(child)) { + has_coretile_hdlcd = true; + break; + } + } + + /* + * If there is a coretile HDLCD and it has a driver, + * do not mux the CLCD on the motherboard to the DVI. + */ + if (has_coretile_hdlcd && IS_ENABLED(CONFIG_DRM_HDLCD)) + mux_motherboard = false; + + /* + * On the Vexpress CA9 we let the CLCD on the coretile + * take precedence, so also in this case do not mux the + * motherboard to the DVI. + */ + if (has_coretile_clcd) + mux_motherboard = false; + + if (mux_motherboard) { + dev_info(dev, "DVI muxed to motherboard CLCD\n"); + val = VEXPRESS_FPGAMUX_MOTHERBOARD; + } else if (ct_clcd == dev->of_node) { + dev_info(dev, + "DVI muxed to daughterboard 1 (core tile) CLCD\n"); + val = VEXPRESS_FPGAMUX_DAUGHTERBOARD_1; + } else { + dev_info(dev, "core tile graphics present\n"); + dev_info(dev, "this device will be deactivated\n"); + return -ENODEV; + } + + ret = regmap_write(map, 0, val); + if (ret) { + dev_err(dev, "error setting DVI muxmode\n"); + return -ENODEV; + } + + return 0; +} + +/* + * This sets up the regmap pointer that will then be retrieved by + * the detection code in pl111_versatile.c and passed in to the + * pl111_vexpress_clcd_init() function above. + */ +static int vexpress_muxfpga_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct regmap *map; + + map = devm_regmap_init_vexpress_config(&pdev->dev); + if (IS_ERR(map)) + return PTR_ERR(map); + dev_set_drvdata(dev, map); + + return 0; +} + +static const struct of_device_id vexpress_muxfpga_match[] = { + { .compatible = "arm,vexpress-muxfpga", } +}; + +static struct platform_driver vexpress_muxfpga_driver = { + .driver = { + .name = "vexpress-muxfpga", + .of_match_table = of_match_ptr(vexpress_muxfpga_match), + }, + .probe = vexpress_muxfpga_probe, +}; + +module_platform_driver(vexpress_muxfpga_driver); diff --git a/drivers/gpu/drm/pl111/pl111_vexpress.h b/drivers/gpu/drm/pl111/pl111_vexpress.h new file mode 100644 index 000000000000..49876417f7b6 --- /dev/null +++ b/drivers/gpu/drm/pl111/pl111_vexpress.h @@ -0,0 +1,22 @@ +// SPDX-License-Identifier: GPL-2.0 + +struct device; +struct pl111_drm_dev_private; +struct regmap; + +#ifdef CONFIG_ARCH_VEXPRESS + +int pl111_vexpress_clcd_init(struct device *dev, + struct pl111_drm_dev_private *priv, + struct regmap *map); + +#else + +static int inline pl111_vexpress_clcd_init(struct device *dev, + struct pl111_drm_dev_private *priv, + struct regmap *map) +{ + return -ENODEV; +} + +#endif -- 2.14.3 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Linus Walleij Subject: [PATCH 1/2 v3] drm/pl111: Support the Versatile Express Date: Wed, 18 Apr 2018 10:52:41 +0200 Message-ID: <20180418085242.19525-1-linus.walleij@linaro.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-lf0-x234.google.com (mail-lf0-x234.google.com [IPv6:2a00:1450:4010:c07::234]) by gabe.freedesktop.org (Postfix) with ESMTPS id 155B76E546 for ; Wed, 18 Apr 2018 08:53:10 +0000 (UTC) Received: by mail-lf0-x234.google.com with SMTP id r125-v6so1459288lfe.2 for ; Wed, 18 Apr 2018 01:53:09 -0700 (PDT) List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Daniel Vetter , Jani Nikula , Sean Paul , Eric Anholt , Liviu Dudau Cc: Pawel Moll , linux-arm-kernel@lists.infradead.org, dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org VGhlIFZlcnNhdGlsZSBFeHByZXNzIHVzZXMgYSBzcGVjaWFsIGNvbmZpZ3VyYXRpb24gY29udHJv bGxlcgpkZWVwbHkgZW1iZWRkZWQgaW4gdGhlIHN5c3RlbSBtb3RoZXJib2FyZCBGUEdBIHRvIG11 bHRpcGxleCB0aGUKdHdvIHRvIHRocmVlICghKSBkaXNwbGF5IGNvbnRyb2xsZXIgaW5zdGFuY2Vz IG91dCB0byB0aGUgc2luZ2xlClNpSTkwMjIgYnJpZGdlLgoKU2V0IHVwIGFuIGV4dHJhIGZpbGUg d2l0aCB0aGUgbG9naWMgdG8gcHJvYmUgdG8gdGhlIEZQR0EgbXV4CnJlZ2lzdGVyIG9uIHRoZSBz eXN0ZW0gY29udHJvbGxlciBidXMsIHRoZW4gcGFyc2UgdGhlIGRldmljZQp0cmVlIHRvIHNlZSBp ZiB0aGVyZSBpcyBhIENMQ0Qgb3IgSERMQ0QgaW5zdGFuY2Ugb24gdGhlIGNvcmUKdGlsZSAoYWxz byBrbm93biBhcyB0aGUgZGF1Z2h0ZXJib2FyZCkgYnkgbG9va2luZyBpbiB0aGUKcm9vdCBvZiB0 aGUgZGV2aWNlIHRyZWUgZm9yIGNvbXBhdGlibGUgbm9kZXMuCgotIElmIHRoZXJlIGlzIGEgSERM Q0Qgb24gdGhlIGNvcmUgdGlsZSwgYW5kIHRoZXJlIGlzIGEgZHJpdmVyCiAgZm9yIGl0LCB3ZSBl eGl0IHByb2JlIGFuZCBkZWFjdGl2YXRlIHRoZSBtb3RoZXJib2FyZCBDTENELgogIFdlIGRvIG5v dCB0b3VjaCB0aGUgRFZJIG11eCBpbiB0aGlzIGNhc2UsIHRvIG1ha2Ugc3VyZSB3ZQogIGRvbid0 IGJyZWFrIEhETENELgoKLSBJZiB0aGVyZSBpcyBhIENMQ0Qgb24gYm90aCB0aGUgbW90aGVyYm9h cmQgYW5kIHRoZSBjb3JlIHRpbGUKICAob25seSB0aGUgQ0E5IGhhcyB0aGlzKSB0aGUgY29yZSB0 aWxlIENMQ0QgdGFrZXMgcHJlY2VkZW5jZQogIGFuZCBnZXQgbXV4ZWQgdG8gdGhlIERWSSBjb25u ZWN0b3IuCgotIE9ubHkgaWYgdGhlcmUgaXMgbm8gd29ya2luZyBncmFwaGljcyBvbiB0aGUgY29y ZSB0aWxlLCB0aGUKICBtb3RoZXJib2FyZCBDTENEIGlzIHByb2JlZCBhbmQgbXV4ZWQgdG8gdGhl IERWSSBjb25uZWN0b3IuCgpDb3JlIHRpbGUgZ3JhcGhpY3Mgc2hvdWxkIGFsd2F5cyB0YWtlIHBy ZWNlZGVuY2UgYXMgaXQgY2FuCmFkZHJlc3MgYWxsIG1lbW9yeSBhbmQgaXMgYWxzbyBmYXN0ZXIs IGhvd2V2ZXIgdGhlIG1vdGhlcmJvYXJkCkNMQ0QgaXMgZ29vZCB0byBoYXZlIGFyb3VuZCBmb3Ig ZGlhZ25vc3RpY3MgYW5kIHRlc3RpbmcuCgpJdCBpcyBwb3NzaWJsZSB0byB0ZXN0IHRoZSBtb3Ro ZXJib2FyZCBDTENEIGJ5IHNldHRpbmcgdGhlCnN0YXR1cyA9ICJkaXNhYmxlZCIgcHJvcGVydHkg b24gdGhlIGNvcmUgdGlsZSBDTENEIG9yCkhETENELgoKU2NhbGUgZG93biB0aGUgVmVyc2F0aWxl IEV4cHJlc3MgdG8gMTZCUFAgc28gd2UgY2FuIHN1cHBvcnQgYQoxMDI0eDc2OCBkaXNwbGF5IGRl c3BpdGUgdGhlIGJ1cyBiYW5kd2lkdGggcmVzdHJpY3Rpb25zIG9uIHRoaXMKcGxhdGZvcm0uIChU aGUgbW90aGVyYm9hcmQgQ0xDRCBzdXBwb3J0cyBzbGlnaHRseSBsb3dlcgpyZXNvbHV0aW9uLikK CkNjOiBMaXZpdSBEdWRhdSA8bGl2aXUuZHVkYXVAYXJtLmNvbT4KQ2M6IFBhd2VsIE1vbGwgPHBh d2VsLm1vbGxAYXJtLmNvbT4KU2lnbmVkLW9mZi1ieTogTGludXMgV2FsbGVpaiA8bGludXMud2Fs bGVpakBsaW5hcm8ub3JnPgotLS0KQ2hhbmdlTG9nIHYyLT52MzoKLSBSZXdyaXRlIENMQ0QgZGV0 ZWN0aW9uIGFuZCBtdXggcHJpb3JpdHkgbG9naWMsIGxvb2sgaW4KICB0aGUgZGV2aWNlIHRyZWUg cm9vdCBmb3IgY29yZSB0aWxlIGdyYXBoaWNzLgpDaGFuZ2VMb2cgdjEtPnYyOgotIE5vIGNoYW5n ZXMganVzdCByZXBvc3RpbmcgcmViYXNlZCBvbiBtYWlubGluZSBjaGFuZ2VzLgotLS0KIGRyaXZl cnMvZ3B1L2RybS9wbDExMS9NYWtlZmlsZSAgICAgICAgICB8ICAgMSArCiBkcml2ZXJzL2dwdS9k cm0vcGwxMTEvcGwxMTFfdmVyc2F0aWxlLmMgfCAgNDggKysrKysrKysrKystCiBkcml2ZXJzL2dw dS9kcm0vcGwxMTEvcGwxMTFfdmV4cHJlc3MuYyAgfCAxMjcgKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysKIGRyaXZlcnMvZ3B1L2RybS9wbDExMS9wbDExMV92ZXhwcmVzcy5oICB8ICAy MiArKysrKysKIDQgZmlsZXMgY2hhbmdlZCwgMTk3IGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24o LSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vcGwxMTEvcGwxMTFfdmV4cHJl c3MuYwogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS9wbDExMS9wbDExMV92ZXhw cmVzcy5oCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3BsMTExL01ha2VmaWxlIGIvZHJp dmVycy9ncHUvZHJtL3BsMTExL01ha2VmaWxlCmluZGV4IDljNWU4ZGJhOGFjNi4uMTlhODE4OWRj NTRmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcGwxMTEvTWFrZWZpbGUKKysrIGIvZHJp dmVycy9ncHUvZHJtL3BsMTExL01ha2VmaWxlCkBAIC0zLDYgKzMsNyBAQCBwbDExMV9kcm0teSAr PQlwbDExMV9kaXNwbGF5Lm8gXAogCQlwbDExMV92ZXJzYXRpbGUubyBcCiAJCXBsMTExX2Rydi5v CiAKK3BsMTExX2RybS0kKENPTkZJR19BUkNIX1ZFWFBSRVNTKSArPSBwbDExMV92ZXhwcmVzcy5v CiBwbDExMV9kcm0tJChDT05GSUdfREVCVUdfRlMpICs9IHBsMTExX2RlYnVnZnMubwogCiBvYmot JChDT05GSUdfRFJNX1BMMTExKSArPSBwbDExMV9kcm0ubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9n cHUvZHJtL3BsMTExL3BsMTExX3ZlcnNhdGlsZS5jIGIvZHJpdmVycy9ncHUvZHJtL3BsMTExL3Bs MTExX3ZlcnNhdGlsZS5jCmluZGV4IDkzMDJmNTE2MDQ1ZS4uNTY5ZWRmMDJhMzZhIDEwMDY0NAot LS0gYS9kcml2ZXJzL2dwdS9kcm0vcGwxMTEvcGwxMTFfdmVyc2F0aWxlLmMKKysrIGIvZHJpdmVy cy9ncHUvZHJtL3BsMTExL3BsMTExX3ZlcnNhdGlsZS5jCkBAIC0xLDEyICsxLDE0IEBACiAjaW5j bHVkZSA8bGludXgvYW1iYS9jbGNkLXJlZ3MuaD4KICNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4K ICNpbmNsdWRlIDxsaW51eC9vZi5oPgorI2luY2x1ZGUgPGxpbnV4L29mX3BsYXRmb3JtLmg+CiAj aW5jbHVkZSA8bGludXgvcmVnbWFwLmg+CiAjaW5jbHVkZSA8bGludXgvbWZkL3N5c2Nvbi5oPgog I2luY2x1ZGUgPGxpbnV4L2JpdG9wcy5oPgogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2lu Y2x1ZGUgPGRybS9kcm1QLmg+CiAjaW5jbHVkZSAicGwxMTFfdmVyc2F0aWxlLmgiCisjaW5jbHVk ZSAicGwxMTFfdmV4cHJlc3MuaCIKICNpbmNsdWRlICJwbDExMV9kcm0uaCIKIAogc3RhdGljIHN0 cnVjdCByZWdtYXAgKnZlcnNhdGlsZV9zeXNjb25fbWFwOwpAQCAtMjIsNiArMjQsNyBAQCBlbnVt IHZlcnNhdGlsZV9jbGNkIHsKIAlSRUFMVklFV19DTENEX1BCMTFNUCwKIAlSRUFMVklFV19DTENE X1BCQTgsCiAJUkVBTFZJRVdfQ0xDRF9QQlgsCisJVkVYUFJFU1NfQ0xDRF9WMk0sCiB9OwogCiBz dGF0aWMgY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCB2ZXJzYXRpbGVfY2xjZF9vZl9tYXRjaFtd ID0gewpAQCAtNTMsNiArNTYsMTAgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQg dmVyc2F0aWxlX2NsY2Rfb2ZfbWF0Y2hbXSA9IHsKIAkJLmNvbXBhdGlibGUgPSAiYXJtLHJlYWx2 aWV3LXBieC1zeXNjb24iLAogCQkuZGF0YSA9ICh2b2lkICopUkVBTFZJRVdfQ0xDRF9QQlgsCiAJ fSwKKwl7CisJCS5jb21wYXRpYmxlID0gImFybSx2ZXhwcmVzcy1tdXhmcGdhIiwKKwkJLmRhdGEg PSAodm9pZCAqKVZFWFBSRVNTX0NMQ0RfVjJNLAorCX0sCiAJe30sCiB9OwogCkBAIC0yODYsMTIg KzI5MywyNiBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IHBsMTExX3ZhcmlhbnRfZGF0YSBwbDExMV9y ZWFsdmlldyA9IHsKIAkuZmJfYnBwID0gMTYsCiB9OwogCisvKgorICogVmVyc2F0aWxlIEV4cHJl c3MgUEwxMTEgdmFyaWFudCwgYWdhaW4gd2UganVzdCBwdXNoIHRoZSBtYXhpbXVtCisgKiBCUFAg dG8gMTYgdG8gYmUgYWJsZSB0byBnZXQgMTAyNHg3Njggd2l0aG91dCBzYXR1cmF0aW5nIHRoZSBt ZW1vcnkKKyAqIGJ1cy4gVGhlIGNsb2NrZGl2aWRlciBhbHNvIHNlZW1zIGJyb2tlbiBvbiB0aGUg VmVyc2F0aWxlIEV4cHJlc3MuCisgKi8KK3N0YXRpYyBjb25zdCBzdHJ1Y3QgcGwxMTFfdmFyaWFu dF9kYXRhIHBsMTExX3ZleHByZXNzID0geworCS5uYW1lID0gIlBMMTExIFZlcnNhdGlsZSBFeHBy ZXNzIiwKKwkuZm9ybWF0cyA9IHBsMTExX3JlYWx2aWV3X3BpeGVsX2Zvcm1hdHMsCisJLm5mb3Jt YXRzID0gQVJSQVlfU0laRShwbDExMV9yZWFsdmlld19waXhlbF9mb3JtYXRzKSwKKwkuZmJfYnBw ID0gMTYsCisJLmJyb2tlbl9jbG9ja2RpdmlkZXIgPSB0cnVlLAorfTsKKwogaW50IHBsMTExX3Zl cnNhdGlsZV9pbml0KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHBsMTExX2RybV9kZXZfcHJp dmF0ZSAqcHJpdikKIHsKIAljb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkICpjbGNkX2lkOwogCWVu dW0gdmVyc2F0aWxlX2NsY2QgdmVyc2F0aWxlX2NsY2RfdHlwZTsKIAlzdHJ1Y3QgZGV2aWNlX25v ZGUgKm5wOwogCXN0cnVjdCByZWdtYXAgKm1hcDsKKwlpbnQgcmV0OwogCiAJbnAgPSBvZl9maW5k X21hdGNoaW5nX25vZGVfYW5kX21hdGNoKE5VTEwsIHZlcnNhdGlsZV9jbGNkX29mX21hdGNoLAog CQkJCQkgICAgICZjbGNkX2lkKTsKQEAgLTMwMSw3ICszMjIsMjUgQEAgaW50IHBsMTExX3ZlcnNh dGlsZV9pbml0KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHBsMTExX2RybV9kZXZfcHJpdmF0 ZSAqcHJpdikKIAl9CiAJdmVyc2F0aWxlX2NsY2RfdHlwZSA9IChlbnVtIHZlcnNhdGlsZV9jbGNk KWNsY2RfaWQtPmRhdGE7CiAKLQltYXAgPSBzeXNjb25fbm9kZV90b19yZWdtYXAobnApOworCS8q IFZlcnNhdGlsZSBFeHByZXNzIHNwZWNpYWwgaGFuZGxpbmcgKi8KKwlpZiAodmVyc2F0aWxlX2Ns Y2RfdHlwZSA9PSBWRVhQUkVTU19DTENEX1YyTSkgeworCQlzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNl ICpwZGV2OworCisJCS8qIENhbGwgaW50byBkZWVwIFZleHByZXNzIGNvbmZpZ3VyYXRpb24gQVBJ ICovCisJCXBkZXYgPSBvZl9maW5kX2RldmljZV9ieV9ub2RlKG5wKTsKKwkJaWYgKCFwZGV2KSB7 CisJCQlkZXZfZXJyKGRldiwgImNhbid0IGZpbmQgdGhlIHN5c3JlZyBkZXZpY2UsIGRlZmVycmlu Z1xuIik7CisJCQlyZXR1cm4gLUVQUk9CRV9ERUZFUjsKKwkJfQorCQltYXAgPSBkZXZfZ2V0X2Ry dmRhdGEoJnBkZXYtPmRldik7CisJCWlmICghbWFwKSB7CisJCQlkZXZfZXJyKGRldiwgInN5c3Jl ZyBoYXMgbm90IHlldCBwcm9iZWRcbiIpOworCQkJcmV0dXJuIC1FUFJPQkVfREVGRVI7CisJCX0K Kwl9IGVsc2UgeworCQltYXAgPSBzeXNjb25fbm9kZV90b19yZWdtYXAobnApOworCX0KKwogCWlm IChJU19FUlIobWFwKSkgewogCQlkZXZfZXJyKGRldiwgIm5vIFZlcnNhdGlsZSBzeXNjb24gcmVn bWFwXG4iKTsKIAkJcmV0dXJuIFBUUl9FUlIobWFwKTsKQEAgLTM0MCw2ICszNzksMTMgQEAgaW50 IHBsMTExX3ZlcnNhdGlsZV9pbml0KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHBsMTExX2Ry bV9kZXZfcHJpdmF0ZSAqcHJpdikKIAkJcHJpdi0+dmFyaWFudF9kaXNwbGF5X2Rpc2FibGUgPSBw bDExMV9yZWFsdmlld19jbGNkX2Rpc2FibGU7CiAJCWRldl9pbmZvKGRldiwgInNldCB1cCBjYWxs YmFja3MgZm9yIFJlYWxWaWV3IFBMMTExXG4iKTsKIAkJYnJlYWs7CisJY2FzZSBWRVhQUkVTU19D TENEX1YyTToKKwkJcHJpdi0+dmFyaWFudCA9ICZwbDExMV92ZXhwcmVzczsKKwkJZGV2X2luZm8o ZGV2LCAiaW5pdGlhbGl6aW5nIFZlcnNhdGlsZSBFeHByZXNzIFBMMTExXG4iKTsKKwkJcmV0ID0g cGwxMTFfdmV4cHJlc3NfY2xjZF9pbml0KGRldiwgcHJpdiwgbWFwKTsKKwkJaWYgKHJldCkKKwkJ CXJldHVybiByZXQ7CisJCWJyZWFrOwogCWRlZmF1bHQ6CiAJCWRldl9pbmZvKGRldiwgInVua25v d24gVmVyc2F0aWxlIHN5c3RlbSBjb250cm9sbGVyXG4iKTsKIAkJYnJlYWs7CmRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vcGwxMTEvcGwxMTFfdmV4cHJlc3MuYyBiL2RyaXZlcnMvZ3B1L2Ry bS9wbDExMS9wbDExMV92ZXhwcmVzcy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMC4uNTY5MDgwMjc2NTlmCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJt L3BsMTExL3BsMTExX3ZleHByZXNzLmMKQEAgLTAsMCArMSwxMjcgQEAKKy8vIFNQRFgtTGljZW5z ZS1JZGVudGlmaWVyOiBHUEwtMi4wCisvKgorICogVmVyc2F0aWxlIEV4cHJlc3MgUEwxMTEgaGFu ZGxpbmcKKyAqIENvcHlyaWdodCAoQykgMjAxOCBMaW51cyBXYWxsZWlqCisgKgorICogVGhpcyBt b2R1bGUgYmluZHMgdG8gdGhlICJhcm0sdmV4cHJlc3MtbXV4ZnBnYSIgZGV2aWNlIG9uIHRoZQor ICogVmVyc2F0aWxlIEV4cHJlc3MgY29uZmlndXJhdGlvbiBidXMgYW5kIHNldHMgdXAgd2hpY2gg Q0xDRCBpbnN0YW5jZQorICogZ2V0cyBtdXhlZCBvdXQgb24gdGhlIERWSSBicmlkZ2UuCisgKi8K KyNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNp bmNsdWRlIDxsaW51eC9yZWdtYXAuaD4KKyNpbmNsdWRlIDxsaW51eC92ZXhwcmVzcy5oPgorI2lu Y2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L29mLmg+Cisj aW5jbHVkZSA8bGludXgvb2ZfYWRkcmVzcy5oPgorI2luY2x1ZGUgPGxpbnV4L29mX3BsYXRmb3Jt Lmg+CisjaW5jbHVkZSAicGwxMTFfZHJtLmgiCisjaW5jbHVkZSAicGwxMTFfdmV4cHJlc3MuaCIK KworI2RlZmluZSBWRVhQUkVTU19GUEdBTVVYX01PVEhFUkJPQVJECQkweDAwCisjZGVmaW5lIFZF WFBSRVNTX0ZQR0FNVVhfREFVR0hURVJCT0FSRF8xCTB4MDEKKyNkZWZpbmUgVkVYUFJFU1NfRlBH QU1VWF9EQVVHSFRFUkJPQVJEXzIJMHgwMgorCitpbnQgcGwxMTFfdmV4cHJlc3NfY2xjZF9pbml0 KHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCSAgICAgc3RydWN0IHBsMTExX2RybV9kZXZfcHJpdmF0 ZSAqcHJpdiwKKwkJCSAgICAgc3RydWN0IHJlZ21hcCAqbWFwKQoreworCXN0cnVjdCBkZXZpY2Vf bm9kZSAqcm9vdDsKKwlzdHJ1Y3QgZGV2aWNlX25vZGUgKmNoaWxkOworCXN0cnVjdCBkZXZpY2Vf bm9kZSAqY3RfY2xjZCA9IE5VTEw7CisJYm9vbCBoYXNfY29yZXRpbGVfY2xjZCA9IGZhbHNlOwor CWJvb2wgaGFzX2NvcmV0aWxlX2hkbGNkID0gZmFsc2U7CisJYm9vbCBtdXhfbW90aGVyYm9hcmQg PSB0cnVlOworCXUzMiB2YWw7CisJaW50IHJldDsKKworCS8qCisJICogQ2hlY2sgaWYgd2UgaGF2 ZSBhIENMQ0Qgb3IgSERMQ0Qgb24gdGhlIGNvcmUgdGlsZSBieSBjaGVja2luZyBpZiBhCisJICog Q0xDRCBvciBIRExDRCBpcyBhdmFpbGFibGUgaW4gdGhlIHJvb3Qgb2YgdGhlIGRldmljZSB0cmVl LgorCSAqLworCXJvb3QgPSBvZl9maW5kX25vZGVfYnlfcGF0aCgiLyIpOworCWlmICghcm9vdCkK KwkJcmV0dXJuIC1FSU5WQUw7CisKKwlmb3JfZWFjaF9jaGlsZF9vZl9ub2RlKHJvb3QsIGNoaWxk KSB7CisJCWlmIChvZl9kZXZpY2VfaXNfY29tcGF0aWJsZShjaGlsZCwgImFybSxwbDExMSIpCisJ CSAgICAmJiBvZl9kZXZpY2VfaXNfYXZhaWxhYmxlKGNoaWxkKSkgeworCQkJaGFzX2NvcmV0aWxl X2NsY2QgPSB0cnVlOworCQkJY3RfY2xjZCA9IGNoaWxkOworCQkJYnJlYWs7CisJCX0KKwkJaWYg KG9mX2RldmljZV9pc19jb21wYXRpYmxlKGNoaWxkLCAiYXJtLGhkbGNkIikKKwkJICAgICYmIG9m X2RldmljZV9pc19hdmFpbGFibGUoY2hpbGQpKSB7CisJCQloYXNfY29yZXRpbGVfaGRsY2QgPSB0 cnVlOworCQkJYnJlYWs7CisJCX0KKwl9CisKKwkvKgorCSAqIElmIHRoZXJlIGlzIGEgY29yZXRp bGUgSERMQ0QgYW5kIGl0IGhhcyBhIGRyaXZlciwKKwkgKiBkbyBub3QgbXV4IHRoZSBDTENEIG9u IHRoZSBtb3RoZXJib2FyZCB0byB0aGUgRFZJLgorCSAqLworCWlmIChoYXNfY29yZXRpbGVfaGRs Y2QgJiYgSVNfRU5BQkxFRChDT05GSUdfRFJNX0hETENEKSkKKwkJbXV4X21vdGhlcmJvYXJkID0g ZmFsc2U7CisKKwkvKgorCSAqIE9uIHRoZSBWZXhwcmVzcyBDQTkgd2UgbGV0IHRoZSBDTENEIG9u IHRoZSBjb3JldGlsZQorCSAqIHRha2UgcHJlY2VkZW5jZSwgc28gYWxzbyBpbiB0aGlzIGNhc2Ug ZG8gbm90IG11eCB0aGUKKwkgKiBtb3RoZXJib2FyZCB0byB0aGUgRFZJLgorCSAqLworCWlmICho YXNfY29yZXRpbGVfY2xjZCkKKwkJbXV4X21vdGhlcmJvYXJkID0gZmFsc2U7CisKKwlpZiAobXV4 X21vdGhlcmJvYXJkKSB7CisJCWRldl9pbmZvKGRldiwgIkRWSSBtdXhlZCB0byBtb3RoZXJib2Fy ZCBDTENEXG4iKTsKKwkJdmFsID0gVkVYUFJFU1NfRlBHQU1VWF9NT1RIRVJCT0FSRDsKKwl9IGVs c2UgaWYgKGN0X2NsY2QgPT0gZGV2LT5vZl9ub2RlKSB7CisJCWRldl9pbmZvKGRldiwKKwkJCSAi RFZJIG11eGVkIHRvIGRhdWdodGVyYm9hcmQgMSAoY29yZSB0aWxlKSBDTENEXG4iKTsKKwkJdmFs ID0gVkVYUFJFU1NfRlBHQU1VWF9EQVVHSFRFUkJPQVJEXzE7CisJfSBlbHNlIHsKKwkJZGV2X2lu Zm8oZGV2LCAiY29yZSB0aWxlIGdyYXBoaWNzIHByZXNlbnRcbiIpOworCQlkZXZfaW5mbyhkZXYs ICJ0aGlzIGRldmljZSB3aWxsIGJlIGRlYWN0aXZhdGVkXG4iKTsKKwkJcmV0dXJuIC1FTk9ERVY7 CisJfQorCisJcmV0ID0gcmVnbWFwX3dyaXRlKG1hcCwgMCwgdmFsKTsKKwlpZiAocmV0KSB7CisJ CWRldl9lcnIoZGV2LCAiZXJyb3Igc2V0dGluZyBEVkkgbXV4bW9kZVxuIik7CisJCXJldHVybiAt RU5PREVWOworCX0KKworCXJldHVybiAwOworfQorCisvKgorICogVGhpcyBzZXRzIHVwIHRoZSBy ZWdtYXAgcG9pbnRlciB0aGF0IHdpbGwgdGhlbiBiZSByZXRyaWV2ZWQgYnkKKyAqIHRoZSBkZXRl Y3Rpb24gY29kZSBpbiBwbDExMV92ZXJzYXRpbGUuYyBhbmQgcGFzc2VkIGluIHRvIHRoZQorICog cGwxMTFfdmV4cHJlc3NfY2xjZF9pbml0KCkgZnVuY3Rpb24gYWJvdmUuCisgKi8KK3N0YXRpYyBp bnQgdmV4cHJlc3NfbXV4ZnBnYV9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQor eworCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZwZGV2LT5kZXY7CisJc3RydWN0IHJlZ21hcCAqbWFw OworCisJbWFwID0gZGV2bV9yZWdtYXBfaW5pdF92ZXhwcmVzc19jb25maWcoJnBkZXYtPmRldik7 CisJaWYgKElTX0VSUihtYXApKQorCQlyZXR1cm4gUFRSX0VSUihtYXApOworCWRldl9zZXRfZHJ2 ZGF0YShkZXYsIG1hcCk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBv Zl9kZXZpY2VfaWQgdmV4cHJlc3NfbXV4ZnBnYV9tYXRjaFtdID0geworCXsgLmNvbXBhdGlibGUg PSAiYXJtLHZleHByZXNzLW11eGZwZ2EiLCB9Cit9OworCitzdGF0aWMgc3RydWN0IHBsYXRmb3Jt X2RyaXZlciB2ZXhwcmVzc19tdXhmcGdhX2RyaXZlciA9IHsKKwkuZHJpdmVyID0geworCQkubmFt ZSA9ICJ2ZXhwcmVzcy1tdXhmcGdhIiwKKwkJLm9mX21hdGNoX3RhYmxlID0gb2ZfbWF0Y2hfcHRy KHZleHByZXNzX211eGZwZ2FfbWF0Y2gpLAorCX0sCisJLnByb2JlID0gdmV4cHJlc3NfbXV4ZnBn YV9wcm9iZSwKK307CisKK21vZHVsZV9wbGF0Zm9ybV9kcml2ZXIodmV4cHJlc3NfbXV4ZnBnYV9k cml2ZXIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3BsMTExL3BsMTExX3ZleHByZXNz LmggYi9kcml2ZXJzL2dwdS9kcm0vcGwxMTEvcGwxMTFfdmV4cHJlc3MuaApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjQ5ODc2NDE3ZjdiNgotLS0gL2Rldi9udWxsCisr KyBiL2RyaXZlcnMvZ3B1L2RybS9wbDExMS9wbDExMV92ZXhwcmVzcy5oCkBAIC0wLDAgKzEsMjIg QEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCisKK3N0cnVjdCBkZXZpY2U7 CitzdHJ1Y3QgcGwxMTFfZHJtX2Rldl9wcml2YXRlOworc3RydWN0IHJlZ21hcDsKKworI2lmZGVm IENPTkZJR19BUkNIX1ZFWFBSRVNTCisKK2ludCBwbDExMV92ZXhwcmVzc19jbGNkX2luaXQoc3Ry dWN0IGRldmljZSAqZGV2LAorCQkJICAgICBzdHJ1Y3QgcGwxMTFfZHJtX2Rldl9wcml2YXRlICpw cml2LAorCQkJICAgICBzdHJ1Y3QgcmVnbWFwICptYXApOworCisjZWxzZQorCitzdGF0aWMgaW50 IGlubGluZSBwbDExMV92ZXhwcmVzc19jbGNkX2luaXQoc3RydWN0IGRldmljZSAqZGV2LAorCQkJ CQkgICBzdHJ1Y3QgcGwxMTFfZHJtX2Rldl9wcml2YXRlICpwcml2LAorCQkJCQkgICBzdHJ1Y3Qg cmVnbWFwICptYXApCit7CisJcmV0dXJuIC1FTk9ERVY7Cit9CisKKyNlbmRpZgotLSAKMi4xNC4z CgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2 ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9s aXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK