From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754242AbdEXRqE (ORCPT ); Wed, 24 May 2017 13:46:04 -0400 Received: from mezzanine.sirena.org.uk ([106.187.55.193]:52676 "EHLO mezzanine.sirena.org.uk" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754220AbdEXRp7 (ORCPT ); Wed, 24 May 2017 13:45:59 -0400 From: Mark Brown To: Kuninori Morimoto Cc: Mark Brown , Mark Brown , Archit Taneja , Jose Abreu , Linux-ALSA , Laurent Pinchart , David Airlie , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-renesas-soc@vger.kernel.org, Russell King , Simon , alsa-devel@alsa-project.org In-Reply-To: <87a86boskr.wl%kuninori.morimoto.gx@renesas.com> Message-Id: Date: Wed, 24 May 2017 18:45:48 +0100 X-SA-Exim-Connect-IP: 2001:470:1f1d:6b5::3 X-SA-Exim-Mail-From: broonie@sirena.org.uk Subject: Applied "ASoC: hdmi-codec: remove multi detection support" to the asoc tree X-SA-Exim-Version: 4.2.1 (built Mon, 26 Dec 2011 16:24:06 +0000) X-SA-Exim-Scanned: No (on mezzanine.sirena.org.uk); Unknown failure Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The patch ASoC: hdmi-codec: remove multi detection support has been applied to the asoc tree at git://git.kernel.org/pub/scm/linux/kernel/git/broonie/sound.git All being well this means that it will be integrated into the linux-next tree (usually sometime in the next 24 hours) and sent to Linus during the next merge window (or sooner if it is a bug fix), however if problems are discovered then the patch may be dropped or reverted. You may get further e-mails resulting from automated or manual testing and review of the tree, please engage with people reporting problems and send followup patches addressing any issues that are reported if needed. If any updates are required or you are submitting further changes they should be sent as incremental updates against current git, existing patches will not be replaced. Please add any relevant lists and maintainers to the CCs when replying to this mail. Thanks, Mark >>From 24069b589b02cc1292761b0f72623dd50ad1e19c Mon Sep 17 00:00:00 2001 From: Kuninori Morimoto Date: Thu, 18 May 2017 01:40:02 +0000 Subject: [PATCH] ASoC: hdmi-codec: remove multi detection support DesignWare HDMI driver (= dw-hdmi) is supporting HDMI sound, and its probe function was calling sound binding function multiple times as same HDMI device different port. Because of this behavior, commit 9731f82d601 ("ASoC: hdmi-codec: enable multi probe for ...") was added for multi detection case. But, this DesignWare HDMI detection/bind code was exchanged/adjusted by commit 69497eb9234 ("drm: bridge: dw-hdmi: Implement DRM bridge..."). Now, all DesignWare HDMI sound ports are detected as 1 bindng function. Because of this, hdmi-codec multi detection support is no longer needed. Thus, this patch removes commit 9731f82d601 ("ASoC: hdmi-codec: enable multi probe for ..."), and its related commit 340327a62c4 ("ASoC: hdmi-codec: Fix hdmi_of_xlate_dai_name...") commit 8480ac56795 ("ASoC: hdmi-codec: remove HDMI device unregister") commit 0c343a35bfe ("ASoC: hdmi-codec: fix spelling mistake: ...) Signed-off-by: Kuninori Morimoto Signed-off-by: Mark Brown --- sound/soc/codecs/hdmi-codec.c | 88 ++----------------------------------------- 1 file changed, 3 insertions(+), 85 deletions(-) diff --git a/sound/soc/codecs/hdmi-codec.c b/sound/soc/codecs/hdmi-codec.c index a3f15149afcf..8659b76b066a 100644 --- a/sound/soc/codecs/hdmi-codec.c +++ b/sound/soc/codecs/hdmi-codec.c @@ -25,17 +25,6 @@ #include /* This is only to get MAX_ELD_BYTES */ -struct hdmi_device { - struct device *dev; - struct list_head list; - int cnt; -}; -#define pos_to_hdmi_device(pos) container_of((pos), struct hdmi_device, list) -LIST_HEAD(hdmi_device_list); -static DEFINE_MUTEX(hdmi_mutex); - -#define DAI_NAME_SIZE 16 - #define HDMI_CODEC_CHMAP_IDX_UNKNOWN -1 struct hdmi_codec_channel_map_table { @@ -702,6 +691,7 @@ static int hdmi_codec_pcm_new(struct snd_soc_pcm_runtime *rtd, } static struct snd_soc_dai_driver hdmi_i2s_dai = { + .name = "i2s-hifi", .id = DAI_ID_I2S, .playback = { .stream_name = "Playback", @@ -716,6 +706,7 @@ static struct snd_soc_dai_driver hdmi_i2s_dai = { }; static const struct snd_soc_dai_driver hdmi_spdif_dai = { + .name = "spdif-hifi", .id = DAI_ID_SPDIF, .playback = { .stream_name = "Playback", @@ -728,32 +719,6 @@ static const struct snd_soc_dai_driver hdmi_spdif_dai = { .pcm_new = hdmi_codec_pcm_new, }; -static char hdmi_dai_name[][DAI_NAME_SIZE] = { - "hdmi-hifi.0", - "hdmi-hifi.1", - "hdmi-hifi.2", - "hdmi-hifi.3", -}; - -static int hdmi_of_xlate_dai_name(struct snd_soc_component *component, - struct of_phandle_args *args, - const char **dai_name) -{ - int id; - - if (args->args_count) - id = args->args[0]; - else - id = 0; - - if (id < ARRAY_SIZE(hdmi_dai_name)) { - *dai_name = hdmi_dai_name[id]; - return 0; - } - - return -EAGAIN; -} - static struct snd_soc_codec_driver hdmi_codec = { .component_driver = { .controls = hdmi_controls, @@ -762,7 +727,6 @@ static struct snd_soc_codec_driver hdmi_codec = { .num_dapm_widgets = ARRAY_SIZE(hdmi_widgets), .dapm_routes = hdmi_routes, .num_dapm_routes = ARRAY_SIZE(hdmi_routes), - .of_xlate_dai_name = hdmi_of_xlate_dai_name, }, }; @@ -771,8 +735,6 @@ static int hdmi_codec_probe(struct platform_device *pdev) struct hdmi_codec_pdata *hcd = pdev->dev.platform_data; struct device *dev = &pdev->dev; struct hdmi_codec_priv *hcp; - struct hdmi_device *hd; - struct list_head *pos; int dai_count, i = 0; int ret; @@ -794,35 +756,6 @@ static int hdmi_codec_probe(struct platform_device *pdev) if (!hcp) return -ENOMEM; - hd = NULL; - mutex_lock(&hdmi_mutex); - list_for_each(pos, &hdmi_device_list) { - struct hdmi_device *tmp = pos_to_hdmi_device(pos); - - if (tmp->dev == dev->parent) { - hd = tmp; - break; - } - } - - if (!hd) { - hd = devm_kzalloc(dev, sizeof(*hd), GFP_KERNEL); - if (!hd) { - mutex_unlock(&hdmi_mutex); - return -ENOMEM; - } - - hd->dev = dev->parent; - - list_add_tail(&hd->list, &hdmi_device_list); - } - mutex_unlock(&hdmi_mutex); - - if (hd->cnt >= ARRAY_SIZE(hdmi_dai_name)) { - dev_err(dev, "too many hdmi codec are detected\n"); - return -EINVAL; - } - hcp->hcd = *hcd; mutex_init(&hcp->current_stream_lock); @@ -835,14 +768,11 @@ static int hdmi_codec_probe(struct platform_device *pdev) hcp->daidrv[i] = hdmi_i2s_dai; hcp->daidrv[i].playback.channels_max = hcd->max_i2s_channels; - hcp->daidrv[i].name = hdmi_dai_name[hd->cnt++]; i++; } - if (hcd->spdif) { + if (hcd->spdif) hcp->daidrv[i] = hdmi_spdif_dai; - hcp->daidrv[i].name = hdmi_dai_name[hd->cnt++]; - } ret = snd_soc_register_codec(dev, &hdmi_codec, hcp->daidrv, dai_count); @@ -859,20 +789,8 @@ static int hdmi_codec_probe(struct platform_device *pdev) static int hdmi_codec_remove(struct platform_device *pdev) { struct device *dev = &pdev->dev; - struct list_head *pos; struct hdmi_codec_priv *hcp; - mutex_lock(&hdmi_mutex); - list_for_each(pos, &hdmi_device_list) { - struct hdmi_device *tmp = pos_to_hdmi_device(pos); - - if (tmp->dev == dev->parent) { - list_del(pos); - break; - } - } - mutex_unlock(&hdmi_mutex); - hcp = dev_get_drvdata(dev); kfree(hcp->chmap_info); snd_soc_unregister_codec(dev); -- 2.11.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Mark Brown Subject: Applied "ASoC: hdmi-codec: remove multi detection support" to the asoc tree Date: Wed, 24 May 2017 18:45:48 +0100 Message-ID: References: <87a86boskr.wl%kuninori.morimoto.gx@renesas.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <87a86boskr.wl%kuninori.morimoto.gx@renesas.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Kuninori Morimoto Cc: Laurent Pinchart , Simon , Mark Brown , alsa-devel@alsa-project.org, dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, linux-renesas-soc@vger.kernel.org, Russell King , Jose Abreu List-Id: alsa-devel@alsa-project.org VGhlIHBhdGNoCgogICBBU29DOiBoZG1pLWNvZGVjOiByZW1vdmUgbXVsdGkgZGV0ZWN0aW9uIHN1 cHBvcnQKCmhhcyBiZWVuIGFwcGxpZWQgdG8gdGhlIGFzb2MgdHJlZSBhdAoKICAgZ2l0Oi8vZ2l0 Lmtlcm5lbC5vcmcvcHViL3NjbS9saW51eC9rZXJuZWwvZ2l0L2Jyb29uaWUvc291bmQuZ2l0IAoK QWxsIGJlaW5nIHdlbGwgdGhpcyBtZWFucyB0aGF0IGl0IHdpbGwgYmUgaW50ZWdyYXRlZCBpbnRv IHRoZSBsaW51eC1uZXh0CnRyZWUgKHVzdWFsbHkgc29tZXRpbWUgaW4gdGhlIG5leHQgMjQgaG91 cnMpIGFuZCBzZW50IHRvIExpbnVzIGR1cmluZwp0aGUgbmV4dCBtZXJnZSB3aW5kb3cgKG9yIHNv b25lciBpZiBpdCBpcyBhIGJ1ZyBmaXgpLCBob3dldmVyIGlmCnByb2JsZW1zIGFyZSBkaXNjb3Zl cmVkIHRoZW4gdGhlIHBhdGNoIG1heSBiZSBkcm9wcGVkIG9yIHJldmVydGVkLiAgCgpZb3UgbWF5 IGdldCBmdXJ0aGVyIGUtbWFpbHMgcmVzdWx0aW5nIGZyb20gYXV0b21hdGVkIG9yIG1hbnVhbCB0 ZXN0aW5nCmFuZCByZXZpZXcgb2YgdGhlIHRyZWUsIHBsZWFzZSBlbmdhZ2Ugd2l0aCBwZW9wbGUg cmVwb3J0aW5nIHByb2JsZW1zIGFuZApzZW5kIGZvbGxvd3VwIHBhdGNoZXMgYWRkcmVzc2luZyBh bnkgaXNzdWVzIHRoYXQgYXJlIHJlcG9ydGVkIGlmIG5lZWRlZC4KCklmIGFueSB1cGRhdGVzIGFy ZSByZXF1aXJlZCBvciB5b3UgYXJlIHN1Ym1pdHRpbmcgZnVydGhlciBjaGFuZ2VzIHRoZXkKc2hv dWxkIGJlIHNlbnQgYXMgaW5jcmVtZW50YWwgdXBkYXRlcyBhZ2FpbnN0IGN1cnJlbnQgZ2l0LCBl eGlzdGluZwpwYXRjaGVzIHdpbGwgbm90IGJlIHJlcGxhY2VkLgoKUGxlYXNlIGFkZCBhbnkgcmVs ZXZhbnQgbGlzdHMgYW5kIG1haW50YWluZXJzIHRvIHRoZSBDQ3Mgd2hlbiByZXBseWluZwp0byB0 aGlzIG1haWwuCgpUaGFua3MsCk1hcmsKCkZyb20gMjQwNjliNTg5YjAyY2MxMjkyNzYxYjBmNzI2 MjNkZDUwYWQxZTE5YyBNb24gU2VwIDE3IDAwOjAwOjAwIDIwMDEKRnJvbTogS3VuaW5vcmkgTW9y aW1vdG8gPGt1bmlub3JpLm1vcmltb3RvLmd4QHJlbmVzYXMuY29tPgpEYXRlOiBUaHUsIDE4IE1h eSAyMDE3IDAxOjQwOjAyICswMDAwClN1YmplY3Q6IFtQQVRDSF0gQVNvQzogaGRtaS1jb2RlYzog cmVtb3ZlIG11bHRpIGRldGVjdGlvbiBzdXBwb3J0CgpEZXNpZ25XYXJlIEhETUkgZHJpdmVyICg9 IGR3LWhkbWkpIGlzIHN1cHBvcnRpbmcgSERNSSBzb3VuZCwgYW5kIGl0cwpwcm9iZSBmdW5jdGlv biB3YXMgY2FsbGluZyBzb3VuZCBiaW5kaW5nIGZ1bmN0aW9uIG11bHRpcGxlIHRpbWVzIGFzCnNh bWUgSERNSSBkZXZpY2UgZGlmZmVyZW50IHBvcnQuCgpCZWNhdXNlIG9mIHRoaXMgYmVoYXZpb3Is IGNvbW1pdCA5NzMxZjgyZDYwMSAoIkFTb0M6IGhkbWktY29kZWM6IGVuYWJsZQptdWx0aSBwcm9i ZSBmb3IgLi4uIikgd2FzIGFkZGVkIGZvciBtdWx0aSBkZXRlY3Rpb24gY2FzZS4KQnV0LCB0aGlz IERlc2lnbldhcmUgSERNSSBkZXRlY3Rpb24vYmluZCBjb2RlIHdhcyBleGNoYW5nZWQvYWRqdXN0 ZWQgYnkKY29tbWl0IDY5NDk3ZWI5MjM0ICgiZHJtOiBicmlkZ2U6IGR3LWhkbWk6IEltcGxlbWVu dCBEUk0gYnJpZGdlLi4uIikuCk5vdywgYWxsIERlc2lnbldhcmUgSERNSSBzb3VuZCBwb3J0cyBh cmUgZGV0ZWN0ZWQgYXMgMSBiaW5kbmcgZnVuY3Rpb24uCgpCZWNhdXNlIG9mIHRoaXMsIGhkbWkt Y29kZWMgbXVsdGkgZGV0ZWN0aW9uIHN1cHBvcnQgaXMgbm8gbG9uZ2VyIG5lZWRlZC4KVGh1cywg dGhpcyBwYXRjaCByZW1vdmVzCmNvbW1pdCA5NzMxZjgyZDYwMSAoIkFTb0M6IGhkbWktY29kZWM6 IGVuYWJsZSBtdWx0aSBwcm9iZSBmb3IgLi4uIiksCmFuZCBpdHMgcmVsYXRlZApjb21taXQgMzQw MzI3YTYyYzQgKCJBU29DOiBoZG1pLWNvZGVjOiBGaXggaGRtaV9vZl94bGF0ZV9kYWlfbmFtZS4u LiIpCmNvbW1pdCA4NDgwYWM1Njc5NSAoIkFTb0M6IGhkbWktY29kZWM6IHJlbW92ZSBIRE1JIGRl dmljZSB1bnJlZ2lzdGVyIikKY29tbWl0IDBjMzQzYTM1YmZlICgiQVNvQzogaGRtaS1jb2RlYzog Zml4IHNwZWxsaW5nIG1pc3Rha2U6IC4uLikKClNpZ25lZC1vZmYtYnk6IEt1bmlub3JpIE1vcmlt b3RvIDxrdW5pbm9yaS5tb3JpbW90by5neEByZW5lc2FzLmNvbT4KU2lnbmVkLW9mZi1ieTogTWFy ayBCcm93biA8YnJvb25pZUBrZXJuZWwub3JnPgotLS0KIHNvdW5kL3NvYy9jb2RlY3MvaGRtaS1j b2RlYy5jIHwgODggKystLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQog MSBmaWxlIGNoYW5nZWQsIDMgaW5zZXJ0aW9ucygrKSwgODUgZGVsZXRpb25zKC0pCgpkaWZmIC0t Z2l0IGEvc291bmQvc29jL2NvZGVjcy9oZG1pLWNvZGVjLmMgYi9zb3VuZC9zb2MvY29kZWNzL2hk bWktY29kZWMuYwppbmRleCBhM2YxNTE0OWFmY2YuLjg2NTliNzZiMDY2YSAxMDA2NDQKLS0tIGEv c291bmQvc29jL2NvZGVjcy9oZG1pLWNvZGVjLmMKKysrIGIvc291bmQvc29jL2NvZGVjcy9oZG1p LWNvZGVjLmMKQEAgLTI1LDE3ICsyNSw2IEBACiAKICNpbmNsdWRlIDxkcm0vZHJtX2NydGMuaD4g LyogVGhpcyBpcyBvbmx5IHRvIGdldCBNQVhfRUxEX0JZVEVTICovCiAKLXN0cnVjdCBoZG1pX2Rl dmljZSB7Ci0Jc3RydWN0IGRldmljZSAqZGV2OwotCXN0cnVjdCBsaXN0X2hlYWQgbGlzdDsKLQlp bnQgY250OwotfTsKLSNkZWZpbmUgcG9zX3RvX2hkbWlfZGV2aWNlKHBvcykJY29udGFpbmVyX29m KChwb3MpLCBzdHJ1Y3QgaGRtaV9kZXZpY2UsIGxpc3QpCi1MSVNUX0hFQUQoaGRtaV9kZXZpY2Vf bGlzdCk7Ci1zdGF0aWMgREVGSU5FX01VVEVYKGhkbWlfbXV0ZXgpOwotCi0jZGVmaW5lIERBSV9O QU1FX1NJWkUgMTYKLQogI2RlZmluZSBIRE1JX0NPREVDX0NITUFQX0lEWF9VTktOT1dOICAtMQog CiBzdHJ1Y3QgaGRtaV9jb2RlY19jaGFubmVsX21hcF90YWJsZSB7CkBAIC03MDIsNiArNjkxLDcg QEAgc3RhdGljIGludCBoZG1pX2NvZGVjX3BjbV9uZXcoc3RydWN0IHNuZF9zb2NfcGNtX3J1bnRp bWUgKnJ0ZCwKIH0KIAogc3RhdGljIHN0cnVjdCBzbmRfc29jX2RhaV9kcml2ZXIgaGRtaV9pMnNf ZGFpID0geworCS5uYW1lID0gImkycy1oaWZpIiwKIAkuaWQgPSBEQUlfSURfSTJTLAogCS5wbGF5 YmFjayA9IHsKIAkJLnN0cmVhbV9uYW1lID0gIlBsYXliYWNrIiwKQEAgLTcxNiw2ICs3MDYsNyBA QCBzdGF0aWMgc3RydWN0IHNuZF9zb2NfZGFpX2RyaXZlciBoZG1pX2kyc19kYWkgPSB7CiB9Owog CiBzdGF0aWMgY29uc3Qgc3RydWN0IHNuZF9zb2NfZGFpX2RyaXZlciBoZG1pX3NwZGlmX2RhaSA9 IHsKKwkubmFtZSA9ICJzcGRpZi1oaWZpIiwKIAkuaWQgPSBEQUlfSURfU1BESUYsCiAJLnBsYXli YWNrID0gewogCQkuc3RyZWFtX25hbWUgPSAiUGxheWJhY2siLApAQCAtNzI4LDMyICs3MTksNiBA QCBzdGF0aWMgY29uc3Qgc3RydWN0IHNuZF9zb2NfZGFpX2RyaXZlciBoZG1pX3NwZGlmX2RhaSA9 IHsKIAkucGNtX25ldyA9IGhkbWlfY29kZWNfcGNtX25ldywKIH07CiAKLXN0YXRpYyBjaGFyIGhk bWlfZGFpX25hbWVbXVtEQUlfTkFNRV9TSVpFXSA9IHsKLQkiaGRtaS1oaWZpLjAiLAotCSJoZG1p LWhpZmkuMSIsCi0JImhkbWktaGlmaS4yIiwKLQkiaGRtaS1oaWZpLjMiLAotfTsKLQotc3RhdGlj IGludCBoZG1pX29mX3hsYXRlX2RhaV9uYW1lKHN0cnVjdCBzbmRfc29jX2NvbXBvbmVudCAqY29t cG9uZW50LAotCQkJCSAgc3RydWN0IG9mX3BoYW5kbGVfYXJncyAqYXJncywKLQkJCQkgIGNvbnN0 IGNoYXIgKipkYWlfbmFtZSkKLXsKLQlpbnQgaWQ7Ci0KLQlpZiAoYXJncy0+YXJnc19jb3VudCkK LQkJaWQgPSBhcmdzLT5hcmdzWzBdOwotCWVsc2UKLQkJaWQgPSAwOwotCi0JaWYgKGlkIDwgQVJS QVlfU0laRShoZG1pX2RhaV9uYW1lKSkgewotCQkqZGFpX25hbWUgPSBoZG1pX2RhaV9uYW1lW2lk XTsKLQkJcmV0dXJuIDA7Ci0JfQotCi0JcmV0dXJuIC1FQUdBSU47Ci19Ci0KIHN0YXRpYyBzdHJ1 Y3Qgc25kX3NvY19jb2RlY19kcml2ZXIgaGRtaV9jb2RlYyA9IHsKIAkuY29tcG9uZW50X2RyaXZl ciA9IHsKIAkJLmNvbnRyb2xzCQk9IGhkbWlfY29udHJvbHMsCkBAIC03NjIsNyArNzI3LDYgQEAg c3RhdGljIHN0cnVjdCBzbmRfc29jX2NvZGVjX2RyaXZlciBoZG1pX2NvZGVjID0gewogCQkubnVt X2RhcG1fd2lkZ2V0cwk9IEFSUkFZX1NJWkUoaGRtaV93aWRnZXRzKSwKIAkJLmRhcG1fcm91dGVz CQk9IGhkbWlfcm91dGVzLAogCQkubnVtX2RhcG1fcm91dGVzCT0gQVJSQVlfU0laRShoZG1pX3Jv dXRlcyksCi0JCS5vZl94bGF0ZV9kYWlfbmFtZQk9IGhkbWlfb2ZfeGxhdGVfZGFpX25hbWUsCiAJ fSwKIH07CiAKQEAgLTc3MSw4ICs3MzUsNiBAQCBzdGF0aWMgaW50IGhkbWlfY29kZWNfcHJvYmUo c3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAlzdHJ1Y3QgaGRtaV9jb2RlY19wZGF0YSAq aGNkID0gcGRldi0+ZGV2LnBsYXRmb3JtX2RhdGE7CiAJc3RydWN0IGRldmljZSAqZGV2ID0gJnBk ZXYtPmRldjsKIAlzdHJ1Y3QgaGRtaV9jb2RlY19wcml2ICpoY3A7Ci0Jc3RydWN0IGhkbWlfZGV2 aWNlICpoZDsKLQlzdHJ1Y3QgbGlzdF9oZWFkICpwb3M7CiAJaW50IGRhaV9jb3VudCwgaSA9IDA7 CiAJaW50IHJldDsKIApAQCAtNzk0LDM1ICs3NTYsNiBAQCBzdGF0aWMgaW50IGhkbWlfY29kZWNf cHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAlpZiAoIWhjcCkKIAkJcmV0dXJu IC1FTk9NRU07CiAKLQloZCA9IE5VTEw7Ci0JbXV0ZXhfbG9jaygmaGRtaV9tdXRleCk7Ci0JbGlz dF9mb3JfZWFjaChwb3MsICZoZG1pX2RldmljZV9saXN0KSB7Ci0JCXN0cnVjdCBoZG1pX2Rldmlj ZSAqdG1wID0gcG9zX3RvX2hkbWlfZGV2aWNlKHBvcyk7Ci0KLQkJaWYgKHRtcC0+ZGV2ID09IGRl di0+cGFyZW50KSB7Ci0JCQloZCA9IHRtcDsKLQkJCWJyZWFrOwotCQl9Ci0JfQotCi0JaWYgKCFo ZCkgewotCQloZCA9IGRldm1fa3phbGxvYyhkZXYsIHNpemVvZigqaGQpLCBHRlBfS0VSTkVMKTsK LQkJaWYgKCFoZCkgewotCQkJbXV0ZXhfdW5sb2NrKCZoZG1pX211dGV4KTsKLQkJCXJldHVybiAt RU5PTUVNOwotCQl9Ci0KLQkJaGQtPmRldiA9IGRldi0+cGFyZW50OwotCi0JCWxpc3RfYWRkX3Rh aWwoJmhkLT5saXN0LCAmaGRtaV9kZXZpY2VfbGlzdCk7Ci0JfQotCW11dGV4X3VubG9jaygmaGRt aV9tdXRleCk7Ci0KLQlpZiAoaGQtPmNudCA+PSBBUlJBWV9TSVpFKGhkbWlfZGFpX25hbWUpKSB7 Ci0JCWRldl9lcnIoZGV2LCAidG9vIG1hbnkgaGRtaSBjb2RlYyBhcmUgZGV0ZWN0ZWRcbiIpOwot CQlyZXR1cm4gLUVJTlZBTDsKLQl9Ci0KIAloY3AtPmhjZCA9ICpoY2Q7CiAJbXV0ZXhfaW5pdCgm aGNwLT5jdXJyZW50X3N0cmVhbV9sb2NrKTsKIApAQCAtODM1LDE0ICs3NjgsMTEgQEAgc3RhdGlj IGludCBoZG1pX2NvZGVjX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAJCWhj cC0+ZGFpZHJ2W2ldID0gaGRtaV9pMnNfZGFpOwogCQloY3AtPmRhaWRydltpXS5wbGF5YmFjay5j aGFubmVsc19tYXggPQogCQkJaGNkLT5tYXhfaTJzX2NoYW5uZWxzOwotCQloY3AtPmRhaWRydltp XS5uYW1lID0gaGRtaV9kYWlfbmFtZVtoZC0+Y250KytdOwogCQlpKys7CiAJfQogCi0JaWYgKGhj ZC0+c3BkaWYpIHsKKwlpZiAoaGNkLT5zcGRpZikKIAkJaGNwLT5kYWlkcnZbaV0gPSBoZG1pX3Nw ZGlmX2RhaTsKLQkJaGNwLT5kYWlkcnZbaV0ubmFtZSA9IGhkbWlfZGFpX25hbWVbaGQtPmNudCsr XTsKLQl9CiAKIAlyZXQgPSBzbmRfc29jX3JlZ2lzdGVyX2NvZGVjKGRldiwgJmhkbWlfY29kZWMs IGhjcC0+ZGFpZHJ2LAogCQkJCSAgICAgZGFpX2NvdW50KTsKQEAgLTg1OSwyMCArNzg5LDggQEAg c3RhdGljIGludCBoZG1pX2NvZGVjX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYp CiBzdGF0aWMgaW50IGhkbWlfY29kZWNfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBk ZXYpCiB7CiAJc3RydWN0IGRldmljZSAqZGV2ID0gJnBkZXYtPmRldjsKLQlzdHJ1Y3QgbGlzdF9o ZWFkICpwb3M7CiAJc3RydWN0IGhkbWlfY29kZWNfcHJpdiAqaGNwOwogCi0JbXV0ZXhfbG9jaygm aGRtaV9tdXRleCk7Ci0JbGlzdF9mb3JfZWFjaChwb3MsICZoZG1pX2RldmljZV9saXN0KSB7Ci0J CXN0cnVjdCBoZG1pX2RldmljZSAqdG1wID0gcG9zX3RvX2hkbWlfZGV2aWNlKHBvcyk7Ci0KLQkJ aWYgKHRtcC0+ZGV2ID09IGRldi0+cGFyZW50KSB7Ci0JCQlsaXN0X2RlbChwb3MpOwotCQkJYnJl YWs7Ci0JCX0KLQl9Ci0JbXV0ZXhfdW5sb2NrKCZoZG1pX211dGV4KTsKLQogCWhjcCA9IGRldl9n ZXRfZHJ2ZGF0YShkZXYpOwogCWtmcmVlKGhjcC0+Y2htYXBfaW5mbyk7CiAJc25kX3NvY191bnJl Z2lzdGVyX2NvZGVjKGRldik7Ci0tIAoyLjExLjAKCl9fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxp c3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFu L2xpc3RpbmZvL2RyaS1kZXZlbAo=