From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1759589AbcJQWVx (ORCPT ); Mon, 17 Oct 2016 18:21:53 -0400 Received: from mail-pf0-f182.google.com ([209.85.192.182]:33303 "EHLO mail-pf0-f182.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1757623AbcJQWTM (ORCPT ); Mon, 17 Oct 2016 18:19:12 -0400 From: John Stultz To: lkml Cc: John Stultz , David Airlie , Archit Taneja , Laurent Pinchart , Wolfram Sang , Srinivas Kandagatla , =?UTF-8?q?Ville=20Syrj=C3=A4l=C3=A4?= , Boris Brezillon , Andy Green , Dave Long , Guodong Xu , Zhangfei Gao , Mark Brown , Lars-Peter Clausen , Jose Abreu , dri-devel@lists.freedesktop.org Subject: [RESEND][PATCH 1/2 v4] drm/bridge: adv7511: Add Audio support. Date: Mon, 17 Oct 2016 15:18:49 -0700 Message-Id: <1476742730-8526-1-git-send-email-john.stultz@linaro.org> X-Mailer: git-send-email 2.7.4 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This patch adds support to Audio for both adv7511 and adv7533 bridge chips. This patch was originally from [1] by Lars-Peter Clausen and was adapted by Archit Taneja and Srinivas Kandagatla . Then I heavily reworked it to use the hdmi-codec driver. And also folded in some audio packet initialization done by Andy Green . So credit to them, but blame to me. [1] https://github.com/analogdevicesinc/linux/blob/xcomm_zynq/drivers/gpu/drm/i2c/adv7511_audio.c Cc: David Airlie Cc: Archit Taneja Cc: Laurent Pinchart Cc: Wolfram Sang Cc: Srinivas Kandagatla Cc: "Ville Syrjälä" Cc: Boris Brezillon Cc: Andy Green Cc: Dave Long Cc: Guodong Xu Cc: Zhangfei Gao Cc: Mark Brown Cc: Lars-Peter Clausen Cc: Jose Abreu Cc: dri-devel@lists.freedesktop.org Reviewed-by: Archit Taneja Acked-by: Lars-Peter Clausen Signed-off-by: John Stultz --- v4: * Kconfig tweaks suggested by Lars-Peter Clausen v3: * Allowed audio support to be configured in or out, as suggested by Laurent * Minor cleanups suggested by Laurent * Folded in Andy's audio packet initialization patch, as suggested by Archit --- drivers/gpu/drm/bridge/adv7511/Kconfig | 8 + drivers/gpu/drm/bridge/adv7511/Makefile | 1 + drivers/gpu/drm/bridge/adv7511/adv7511.h | 16 ++ drivers/gpu/drm/bridge/adv7511/adv7511_audio.c | 213 +++++++++++++++++++++++++ drivers/gpu/drm/bridge/adv7511/adv7511_drv.c | 4 + 5 files changed, 242 insertions(+) create mode 100644 drivers/gpu/drm/bridge/adv7511/adv7511_audio.c diff --git a/drivers/gpu/drm/bridge/adv7511/Kconfig b/drivers/gpu/drm/bridge/adv7511/Kconfig index d2b0499..2fed567 100644 --- a/drivers/gpu/drm/bridge/adv7511/Kconfig +++ b/drivers/gpu/drm/bridge/adv7511/Kconfig @@ -6,6 +6,14 @@ config DRM_I2C_ADV7511 help Support for the Analog Device ADV7511(W) and ADV7513 HDMI encoders. +config DRM_I2C_ADV7511_AUDIO + bool "ADV7511 HDMI Audio driver" + depends on DRM_I2C_ADV7511 && SND_SOC + select SND_SOC_HDMI_CODEC + help + Support the ADV7511 HDMI Audio interface. This is used in + conjunction with the AV7511 HDMI driver. + config DRM_I2C_ADV7533 bool "ADV7533 encoder" depends on DRM_I2C_ADV7511 diff --git a/drivers/gpu/drm/bridge/adv7511/Makefile b/drivers/gpu/drm/bridge/adv7511/Makefile index 9019327..5ba6755 100644 --- a/drivers/gpu/drm/bridge/adv7511/Makefile +++ b/drivers/gpu/drm/bridge/adv7511/Makefile @@ -1,3 +1,4 @@ adv7511-y := adv7511_drv.o +adv7511-$(CONFIG_DRM_I2C_ADV7511_AUDIO) += adv7511_audio.o adv7511-$(CONFIG_DRM_I2C_ADV7533) += adv7533.o obj-$(CONFIG_DRM_I2C_ADV7511) += adv7511.o diff --git a/drivers/gpu/drm/bridge/adv7511/adv7511.h b/drivers/gpu/drm/bridge/adv7511/adv7511.h index 161c923..992d76c 100644 --- a/drivers/gpu/drm/bridge/adv7511/adv7511.h +++ b/drivers/gpu/drm/bridge/adv7511/adv7511.h @@ -309,6 +309,8 @@ struct adv7511 { struct drm_display_mode curr_mode; unsigned int f_tmds; + unsigned int f_audio; + unsigned int audio_source; unsigned int current_edid_segment; uint8_t edid_buf[256]; @@ -334,6 +336,7 @@ struct adv7511 { bool use_timing_gen; enum adv7511_type type; + struct platform_device *audio_pdev; }; #ifdef CONFIG_DRM_I2C_ADV7533 @@ -389,4 +392,17 @@ static inline int adv7533_parse_dt(struct device_node *np, struct adv7511 *adv) } #endif +#ifdef CONFIG_DRM_I2C_ADV7511_AUDIO +int adv7511_audio_init(struct device *dev, struct adv7511 *adv7511); +void adv7511_audio_exit(struct adv7511 *adv7511); +#else /*CONFIG_DRM_I2C_ADV7511_AUDIO */ +static inline int adv7511_audio_init(struct device *dev, struct adv7511 *adv7511) +{ + return 0; +} +static inline void adv7511_audio_exit(struct adv7511 *adv7511) +{ +} +#endif /* CONFIG_DRM_I2C_ADV7511_AUDIO */ + #endif /* __DRM_I2C_ADV7511_H__ */ diff --git a/drivers/gpu/drm/bridge/adv7511/adv7511_audio.c b/drivers/gpu/drm/bridge/adv7511/adv7511_audio.c new file mode 100644 index 0000000..5ce29a5 --- /dev/null +++ b/drivers/gpu/drm/bridge/adv7511/adv7511_audio.c @@ -0,0 +1,213 @@ +/* + * Analog Devices ADV7511 HDMI transmitter driver + * + * Copyright 2012 Analog Devices Inc. + * Copyright (c) 2016, Linaro Limited + * + * Licensed under the GPL-2. + */ + +#include +#include +#include +#include + +#include "adv7511.h" + +static void adv7511_calc_cts_n(unsigned int f_tmds, unsigned int fs, + unsigned int *cts, unsigned int *n) +{ + switch (fs) { + case 32000: + *n = 4096; + break; + case 44100: + *n = 6272; + break; + case 48000: + *n = 6144; + break; + } + + *cts = ((f_tmds * *n) / (128 * fs)) * 1000; +} + +static int adv7511_update_cts_n(struct adv7511 *adv7511) +{ + unsigned int cts = 0; + unsigned int n = 0; + + adv7511_calc_cts_n(adv7511->f_tmds, adv7511->f_audio, &cts, &n); + + regmap_write(adv7511->regmap, ADV7511_REG_N0, (n >> 16) & 0xf); + regmap_write(adv7511->regmap, ADV7511_REG_N1, (n >> 8) & 0xff); + regmap_write(adv7511->regmap, ADV7511_REG_N2, n & 0xff); + + regmap_write(adv7511->regmap, ADV7511_REG_CTS_MANUAL0, + (cts >> 16) & 0xf); + regmap_write(adv7511->regmap, ADV7511_REG_CTS_MANUAL1, + (cts >> 8) & 0xff); + regmap_write(adv7511->regmap, ADV7511_REG_CTS_MANUAL2, + cts & 0xff); + + return 0; +} + +int adv7511_hdmi_hw_params(struct device *dev, void *data, + struct hdmi_codec_daifmt *fmt, + struct hdmi_codec_params *hparms) +{ + struct adv7511 *adv7511 = dev_get_drvdata(dev); + unsigned int audio_source, i2s_format = 0; + unsigned int invert_clock; + unsigned int rate; + unsigned int len; + + switch (hparms->sample_rate) { + case 32000: + rate = ADV7511_SAMPLE_FREQ_32000; + break; + case 44100: + rate = ADV7511_SAMPLE_FREQ_44100; + break; + case 48000: + rate = ADV7511_SAMPLE_FREQ_48000; + break; + case 88200: + rate = ADV7511_SAMPLE_FREQ_88200; + break; + case 96000: + rate = ADV7511_SAMPLE_FREQ_96000; + break; + case 176400: + rate = ADV7511_SAMPLE_FREQ_176400; + break; + case 192000: + rate = ADV7511_SAMPLE_FREQ_192000; + break; + default: + return -EINVAL; + } + + switch (hparms->sample_width) { + case 16: + len = ADV7511_I2S_SAMPLE_LEN_16; + break; + case 18: + len = ADV7511_I2S_SAMPLE_LEN_18; + break; + case 20: + len = ADV7511_I2S_SAMPLE_LEN_20; + break; + case 24: + len = ADV7511_I2S_SAMPLE_LEN_24; + break; + default: + return -EINVAL; + } + + switch (fmt->fmt) { + case HDMI_I2S: + audio_source = ADV7511_AUDIO_SOURCE_I2S; + i2s_format = ADV7511_I2S_FORMAT_I2S; + break; + case HDMI_RIGHT_J: + audio_source = ADV7511_AUDIO_SOURCE_I2S; + i2s_format = ADV7511_I2S_FORMAT_RIGHT_J; + break; + case HDMI_LEFT_J: + audio_source = ADV7511_AUDIO_SOURCE_I2S; + i2s_format = ADV7511_I2S_FORMAT_LEFT_J; + break; + default: + return -EINVAL; + } + + invert_clock = fmt->bit_clk_inv; + + regmap_update_bits(adv7511->regmap, ADV7511_REG_AUDIO_SOURCE, 0x70, + audio_source << 4); + regmap_update_bits(adv7511->regmap, ADV7511_REG_AUDIO_CONFIG, BIT(6), + invert_clock << 6); + regmap_update_bits(adv7511->regmap, ADV7511_REG_I2S_CONFIG, 0x03, + i2s_format); + + adv7511->audio_source = audio_source; + + adv7511->f_audio = hparms->sample_rate; + + adv7511_update_cts_n(adv7511); + + regmap_update_bits(adv7511->regmap, ADV7511_REG_AUDIO_CFG3, + ADV7511_AUDIO_CFG3_LEN_MASK, len); + regmap_update_bits(adv7511->regmap, ADV7511_REG_I2C_FREQ_ID_CFG, + ADV7511_I2C_FREQ_ID_CFG_RATE_MASK, rate << 4); + regmap_write(adv7511->regmap, 0x73, 0x1); + + return 0; +} + +static int audio_startup(struct device *dev, void *data) +{ + struct adv7511 *adv7511 = dev_get_drvdata(dev); + + regmap_update_bits(adv7511->regmap, ADV7511_REG_AUDIO_CONFIG, + BIT(7), 0); + + /* hide Audio infoframe updates */ + regmap_update_bits(adv7511->regmap, ADV7511_REG_INFOFRAME_UPDATE, + BIT(5), BIT(5)); + /* enable N/CTS, enable Audio sample packets */ + regmap_update_bits(adv7511->regmap, ADV7511_REG_PACKET_ENABLE1, + BIT(5), BIT(5)); + /* enable N/CTS */ + regmap_update_bits(adv7511->regmap, ADV7511_REG_PACKET_ENABLE1, + BIT(6), BIT(6)); + /* not copyrighted */ + regmap_update_bits(adv7511->regmap, ADV7511_REG_AUDIO_CFG1, + BIT(5), BIT(5)); + /* enable audio infoframes */ + regmap_update_bits(adv7511->regmap, ADV7511_REG_PACKET_ENABLE1, + BIT(3), BIT(3)); + /* AV mute disable */ + regmap_update_bits(adv7511->regmap, ADV7511_REG_GC(0), + BIT(7) | BIT(6), BIT(7)); + /* use Audio infoframe updated info */ + regmap_update_bits(adv7511->regmap, ADV7511_REG_GC(1), + BIT(5), 0); + return 0; +} + +static void audio_shutdown(struct device *dev, void *data) +{ +} + +static const struct hdmi_codec_ops adv7511_codec_ops = { + .hw_params = adv7511_hdmi_hw_params, + .audio_shutdown = audio_shutdown, + .audio_startup = audio_startup, +}; + +static struct hdmi_codec_pdata codec_data = { + .ops = &adv7511_codec_ops, + .max_i2s_channels = 2, + .i2s = 1, +}; + +int adv7511_audio_init(struct device *dev, struct adv7511 *adv7511) +{ + adv7511->audio_pdev = platform_device_register_data(dev, + HDMI_CODEC_DRV_NAME, + PLATFORM_DEVID_AUTO, + &codec_data, + sizeof(codec_data)); + return PTR_ERR_OR_ZERO(adv7511->audio_pdev); +} + +void adv7511_audio_exit(struct adv7511 *adv7511) +{ + if (adv7511->audio_pdev) { + platform_device_unregister(adv7511->audio_pdev); + adv7511->audio_pdev = NULL; + } +} diff --git a/drivers/gpu/drm/bridge/adv7511/adv7511_drv.c b/drivers/gpu/drm/bridge/adv7511/adv7511_drv.c index 8ed3906..8dba729 100644 --- a/drivers/gpu/drm/bridge/adv7511/adv7511_drv.c +++ b/drivers/gpu/drm/bridge/adv7511/adv7511_drv.c @@ -1037,6 +1037,8 @@ static int adv7511_probe(struct i2c_client *i2c, const struct i2c_device_id *id) goto err_unregister_cec; } + adv7511_audio_init(dev, adv7511); + return 0; err_unregister_cec: @@ -1058,6 +1060,8 @@ static int adv7511_remove(struct i2c_client *i2c) drm_bridge_remove(&adv7511->bridge); + adv7511_audio_exit(adv7511); + i2c_unregister_device(adv7511->i2c_edid); kfree(adv7511->edid); -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: John Stultz Subject: [RESEND][PATCH 1/2 v4] drm/bridge: adv7511: Add Audio support. Date: Mon, 17 Oct 2016 15:18:49 -0700 Message-ID: <1476742730-8526-1-git-send-email-john.stultz@linaro.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-pf0-x22d.google.com (mail-pf0-x22d.google.com [IPv6:2607:f8b0:400e:c00::22d]) by gabe.freedesktop.org (Postfix) with ESMTPS id D9E256E5D9 for ; Mon, 17 Oct 2016 22:19:11 +0000 (UTC) Received: by mail-pf0-x22d.google.com with SMTP id e6so83702931pfk.3 for ; Mon, 17 Oct 2016 15:19:11 -0700 (PDT) List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: lkml Cc: Guodong Xu , dri-devel@lists.freedesktop.org, Jose Abreu , Wolfram Sang , Mark Brown , Laurent Pinchart , Zhangfei Gao , Andy Green , Srinivas Kandagatla , Dave Long List-Id: dri-devel@lists.freedesktop.org VGhpcyBwYXRjaCBhZGRzIHN1cHBvcnQgdG8gQXVkaW8gZm9yIGJvdGggYWR2NzUxMSBhbmQgYWR2 NzUzMwpicmlkZ2UgY2hpcHMuCgpUaGlzIHBhdGNoIHdhcyBvcmlnaW5hbGx5IGZyb20gWzFdIGJ5 IExhcnMtUGV0ZXIgQ2xhdXNlbiA8bGFyc0BtZXRhZm9vLmRlPgphbmQgd2FzIGFkYXB0ZWQgYnkg QXJjaGl0IFRhbmVqYSA8YXJjaGl0dEBjb2RlYXVyb3JhLm9yZz4gYW5kClNyaW5pdmFzIEthbmRh Z2F0bGEgPHNyaW5pdmFzLmthbmRhZ2F0bGFAbGluYXJvLm9yZz4uCgpUaGVuIEkgaGVhdmlseSBy ZXdvcmtlZCBpdCB0byB1c2UgdGhlIGhkbWktY29kZWMgZHJpdmVyLiBBbmQgYWxzbwpmb2xkZWQg aW4gc29tZSBhdWRpbyBwYWNrZXQgaW5pdGlhbGl6YXRpb24gZG9uZSBieSBBbmR5IEdyZWVuCjxh bmR5LmdyZWVuQGxpbmFyby5vcmc+LiBTbyBjcmVkaXQgdG8gdGhlbSwgYnV0IGJsYW1lIHRvIG1l LgoKWzFdIGh0dHBzOi8vZ2l0aHViLmNvbS9hbmFsb2dkZXZpY2VzaW5jL2xpbnV4L2Jsb2IveGNv bW1fenlucS9kcml2ZXJzL2dwdS9kcm0vaTJjL2Fkdjc1MTFfYXVkaW8uYwoKQ2M6IERhdmlkIEFp cmxpZSA8YWlybGllZEBsaW51eC5pZT4KQ2M6IEFyY2hpdCBUYW5lamEgPGFyY2hpdHRAY29kZWF1 cm9yYS5vcmc+CkNjOiBMYXVyZW50IFBpbmNoYXJ0IDxsYXVyZW50LnBpbmNoYXJ0QGlkZWFzb25i b2FyZC5jb20+CkNjOiBXb2xmcmFtIFNhbmcgPHdzYStyZW5lc2FzQHNhbmctZW5naW5lZXJpbmcu Y29tPgpDYzogU3Jpbml2YXMgS2FuZGFnYXRsYSA8c3Jpbml2YXMua2FuZGFnYXRsYUBsaW5hcm8u b3JnPgpDYzogIlZpbGxlIFN5cmrDpGzDpCIgPHZpbGxlLnN5cmphbGFAbGludXguaW50ZWwuY29t PgpDYzogQm9yaXMgQnJlemlsbG9uIDxib3Jpcy5icmV6aWxsb25AZnJlZS1lbGVjdHJvbnMuY29t PgpDYzogQW5keSBHcmVlbiA8YW5keUB3YXJtY2F0LmNvbT4KQ2M6IERhdmUgTG9uZyA8ZGF2ZS5s b25nQGxpbmFyby5vcmc+CkNjOiBHdW9kb25nIFh1IDxndW9kb25nLnh1QGxpbmFyby5vcmc+CkNj OiBaaGFuZ2ZlaSBHYW8gPHpoYW5nZmVpLmdhb0BsaW5hcm8ub3JnPgpDYzogTWFyayBCcm93biA8 YnJvb25pZUBrZXJuZWwub3JnPgpDYzogTGFycy1QZXRlciBDbGF1c2VuIDxsYXJzQG1ldGFmb28u ZGU+CkNjOiBKb3NlIEFicmV1IDxqb2FicmV1QHN5bm9wc3lzLmNvbT4KQ2M6IGRyaS1kZXZlbEBs aXN0cy5mcmVlZGVza3RvcC5vcmcKUmV2aWV3ZWQtYnk6IEFyY2hpdCBUYW5lamEgPGFyY2hpdHRA Y29kZWF1cm9yYS5vcmc+CkFja2VkLWJ5OiBMYXJzLVBldGVyIENsYXVzZW4gPGxhcnNAbWV0YWZv by5kZT4KU2lnbmVkLW9mZi1ieTogSm9obiBTdHVsdHogPGpvaG4uc3R1bHR6QGxpbmFyby5vcmc+ Ci0tLQp2NDoKKiBLY29uZmlnIHR3ZWFrcyBzdWdnZXN0ZWQgYnkgTGFycy1QZXRlciBDbGF1c2Vu CnYzOgoqIEFsbG93ZWQgYXVkaW8gc3VwcG9ydCB0byBiZSBjb25maWd1cmVkIGluIG9yIG91dCwg YXMgc3VnZ2VzdGVkIGJ5IExhdXJlbnQKKiBNaW5vciBjbGVhbnVwcyBzdWdnZXN0ZWQgYnkgTGF1 cmVudAoqIEZvbGRlZCBpbiBBbmR5J3MgYXVkaW8gcGFja2V0IGluaXRpYWxpemF0aW9uIHBhdGNo LCBhcyBzdWdnZXN0ZWQgYnkgQXJjaGl0Ci0tLQogZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9hZHY3 NTExL0tjb25maWcgICAgICAgICB8ICAgOCArCiBkcml2ZXJzL2dwdS9kcm0vYnJpZGdlL2Fkdjc1 MTEvTWFrZWZpbGUgICAgICAgIHwgICAxICsKIGRyaXZlcnMvZ3B1L2RybS9icmlkZ2UvYWR2NzUx MS9hZHY3NTExLmggICAgICAgfCAgMTYgKysKIGRyaXZlcnMvZ3B1L2RybS9icmlkZ2UvYWR2NzUx MS9hZHY3NTExX2F1ZGlvLmMgfCAyMTMgKysrKysrKysrKysrKysrKysrKysrKysrKwogZHJpdmVy cy9ncHUvZHJtL2JyaWRnZS9hZHY3NTExL2Fkdjc1MTFfZHJ2LmMgICB8ICAgNCArCiA1IGZpbGVz IGNoYW5nZWQsIDI0MiBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9n cHUvZHJtL2JyaWRnZS9hZHY3NTExL2Fkdjc1MTFfYXVkaW8uYwoKZGlmZiAtLWdpdCBhL2RyaXZl cnMvZ3B1L2RybS9icmlkZ2UvYWR2NzUxMS9LY29uZmlnIGIvZHJpdmVycy9ncHUvZHJtL2JyaWRn ZS9hZHY3NTExL0tjb25maWcKaW5kZXggZDJiMDQ5OS4uMmZlZDU2NyAxMDA2NDQKLS0tIGEvZHJp dmVycy9ncHUvZHJtL2JyaWRnZS9hZHY3NTExL0tjb25maWcKKysrIGIvZHJpdmVycy9ncHUvZHJt L2JyaWRnZS9hZHY3NTExL0tjb25maWcKQEAgLTYsNiArNiwxNCBAQCBjb25maWcgRFJNX0kyQ19B RFY3NTExCiAJaGVscAogCSAgU3VwcG9ydCBmb3IgdGhlIEFuYWxvZyBEZXZpY2UgQURWNzUxMShX KSBhbmQgQURWNzUxMyBIRE1JIGVuY29kZXJzLgogCitjb25maWcgRFJNX0kyQ19BRFY3NTExX0FV RElPCisJYm9vbCAiQURWNzUxMSBIRE1JIEF1ZGlvIGRyaXZlciIKKwlkZXBlbmRzIG9uIERSTV9J MkNfQURWNzUxMSAmJiBTTkRfU09DCisJc2VsZWN0IFNORF9TT0NfSERNSV9DT0RFQworCWhlbHAK KwkgIFN1cHBvcnQgdGhlIEFEVjc1MTEgSERNSSBBdWRpbyBpbnRlcmZhY2UuIFRoaXMgaXMgdXNl ZCBpbgorCSAgY29uanVuY3Rpb24gd2l0aCB0aGUgQVY3NTExICBIRE1JIGRyaXZlci4KKwogY29u ZmlnIERSTV9JMkNfQURWNzUzMwogCWJvb2wgIkFEVjc1MzMgZW5jb2RlciIKIAlkZXBlbmRzIG9u IERSTV9JMkNfQURWNzUxMQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9hZHY3 NTExL01ha2VmaWxlIGIvZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9hZHY3NTExL01ha2VmaWxlCmlu ZGV4IDkwMTkzMjcuLjViYTY3NTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9icmlkZ2Uv YWR2NzUxMS9NYWtlZmlsZQorKysgYi9kcml2ZXJzL2dwdS9kcm0vYnJpZGdlL2Fkdjc1MTEvTWFr ZWZpbGUKQEAgLTEsMyArMSw0IEBACiBhZHY3NTExLXkgOj0gYWR2NzUxMV9kcnYubworYWR2NzUx MS0kKENPTkZJR19EUk1fSTJDX0FEVjc1MTFfQVVESU8pICs9IGFkdjc1MTFfYXVkaW8ubwogYWR2 NzUxMS0kKENPTkZJR19EUk1fSTJDX0FEVjc1MzMpICs9IGFkdjc1MzMubwogb2JqLSQoQ09ORklH X0RSTV9JMkNfQURWNzUxMSkgKz0gYWR2NzUxMS5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0vYnJpZGdlL2Fkdjc1MTEvYWR2NzUxMS5oIGIvZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9hZHY3 NTExL2Fkdjc1MTEuaAppbmRleCAxNjFjOTIzLi45OTJkNzZjIDEwMDY0NAotLS0gYS9kcml2ZXJz L2dwdS9kcm0vYnJpZGdlL2Fkdjc1MTEvYWR2NzUxMS5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9i cmlkZ2UvYWR2NzUxMS9hZHY3NTExLmgKQEAgLTMwOSw2ICszMDksOCBAQCBzdHJ1Y3QgYWR2NzUx MSB7CiAJc3RydWN0IGRybV9kaXNwbGF5X21vZGUgY3Vycl9tb2RlOwogCiAJdW5zaWduZWQgaW50 IGZfdG1kczsKKwl1bnNpZ25lZCBpbnQgZl9hdWRpbzsKKwl1bnNpZ25lZCBpbnQgYXVkaW9fc291 cmNlOwogCiAJdW5zaWduZWQgaW50IGN1cnJlbnRfZWRpZF9zZWdtZW50OwogCXVpbnQ4X3QgZWRp ZF9idWZbMjU2XTsKQEAgLTMzNCw2ICszMzYsNyBAQCBzdHJ1Y3QgYWR2NzUxMSB7CiAJYm9vbCB1 c2VfdGltaW5nX2dlbjsKIAogCWVudW0gYWR2NzUxMV90eXBlIHR5cGU7CisJc3RydWN0IHBsYXRm b3JtX2RldmljZSAqYXVkaW9fcGRldjsKIH07CiAKICNpZmRlZiBDT05GSUdfRFJNX0kyQ19BRFY3 NTMzCkBAIC0zODksNCArMzkyLDE3IEBAIHN0YXRpYyBpbmxpbmUgaW50IGFkdjc1MzNfcGFyc2Vf ZHQoc3RydWN0IGRldmljZV9ub2RlICpucCwgc3RydWN0IGFkdjc1MTEgKmFkdikKIH0KICNlbmRp ZgogCisjaWZkZWYgQ09ORklHX0RSTV9JMkNfQURWNzUxMV9BVURJTworaW50IGFkdjc1MTFfYXVk aW9faW5pdChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBhZHY3NTExICphZHY3NTExKTsKK3Zv aWQgYWR2NzUxMV9hdWRpb19leGl0KHN0cnVjdCBhZHY3NTExICphZHY3NTExKTsKKyNlbHNlIC8q Q09ORklHX0RSTV9JMkNfQURWNzUxMV9BVURJTyAqLworc3RhdGljIGlubGluZSBpbnQgYWR2NzUx MV9hdWRpb19pbml0KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGFkdjc1MTEgKmFkdjc1MTEp Cit7CisJcmV0dXJuIDA7Cit9CitzdGF0aWMgaW5saW5lIHZvaWQgYWR2NzUxMV9hdWRpb19leGl0 KHN0cnVjdCBhZHY3NTExICphZHY3NTExKQoreworfQorI2VuZGlmIC8qIENPTkZJR19EUk1fSTJD X0FEVjc1MTFfQVVESU8gKi8KKwogI2VuZGlmIC8qIF9fRFJNX0kyQ19BRFY3NTExX0hfXyAqLwpk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9hZHY3NTExL2Fkdjc1MTFfYXVkaW8u YyBiL2RyaXZlcnMvZ3B1L2RybS9icmlkZ2UvYWR2NzUxMS9hZHY3NTExX2F1ZGlvLmMKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNWNlMjlhNQotLS0gL2Rldi9udWxsCisrKyBi L2RyaXZlcnMvZ3B1L2RybS9icmlkZ2UvYWR2NzUxMS9hZHY3NTExX2F1ZGlvLmMKQEAgLTAsMCAr MSwyMTMgQEAKKy8qCisgKiBBbmFsb2cgRGV2aWNlcyBBRFY3NTExIEhETUkgdHJhbnNtaXR0ZXIg ZHJpdmVyCisgKgorICogQ29weXJpZ2h0IDIwMTIgQW5hbG9nIERldmljZXMgSW5jLgorICogQ29w eXJpZ2h0IChjKSAyMDE2LCBMaW5hcm8gTGltaXRlZAorICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRo ZSBHUEwtMi4KKyAqLworCisjaW5jbHVkZSA8c291bmQvY29yZS5oPgorI2luY2x1ZGUgPHNvdW5k L2hkbWktY29kZWMuaD4KKyNpbmNsdWRlIDxzb3VuZC9wY20uaD4KKyNpbmNsdWRlIDxzb3VuZC9z b2MuaD4KKworI2luY2x1ZGUgImFkdjc1MTEuaCIKKworc3RhdGljIHZvaWQgYWR2NzUxMV9jYWxj X2N0c19uKHVuc2lnbmVkIGludCBmX3RtZHMsIHVuc2lnbmVkIGludCBmcywKKwkJCSAgICAgICB1 bnNpZ25lZCBpbnQgKmN0cywgdW5zaWduZWQgaW50ICpuKQoreworCXN3aXRjaCAoZnMpIHsKKwlj YXNlIDMyMDAwOgorCQkqbiA9IDQwOTY7CisJCWJyZWFrOworCWNhc2UgNDQxMDA6CisJCSpuID0g NjI3MjsKKwkJYnJlYWs7CisJY2FzZSA0ODAwMDoKKwkJKm4gPSA2MTQ0OworCQlicmVhazsKKwl9 CisKKwkqY3RzID0gKChmX3RtZHMgKiAqbikgLyAoMTI4ICogZnMpKSAqIDEwMDA7Cit9CisKK3N0 YXRpYyBpbnQgYWR2NzUxMV91cGRhdGVfY3RzX24oc3RydWN0IGFkdjc1MTEgKmFkdjc1MTEpCit7 CisJdW5zaWduZWQgaW50IGN0cyA9IDA7CisJdW5zaWduZWQgaW50IG4gPSAwOworCisJYWR2NzUx MV9jYWxjX2N0c19uKGFkdjc1MTEtPmZfdG1kcywgYWR2NzUxMS0+Zl9hdWRpbywgJmN0cywgJm4p OworCisJcmVnbWFwX3dyaXRlKGFkdjc1MTEtPnJlZ21hcCwgQURWNzUxMV9SRUdfTjAsIChuID4+ IDE2KSAmIDB4Zik7CisJcmVnbWFwX3dyaXRlKGFkdjc1MTEtPnJlZ21hcCwgQURWNzUxMV9SRUdf TjEsIChuID4+IDgpICYgMHhmZik7CisJcmVnbWFwX3dyaXRlKGFkdjc1MTEtPnJlZ21hcCwgQURW NzUxMV9SRUdfTjIsIG4gJiAweGZmKTsKKworCXJlZ21hcF93cml0ZShhZHY3NTExLT5yZWdtYXAs IEFEVjc1MTFfUkVHX0NUU19NQU5VQUwwLAorCQkgICAgIChjdHMgPj4gMTYpICYgMHhmKTsKKwly ZWdtYXBfd3JpdGUoYWR2NzUxMS0+cmVnbWFwLCBBRFY3NTExX1JFR19DVFNfTUFOVUFMMSwKKwkJ ICAgICAoY3RzID4+IDgpICYgMHhmZik7CisJcmVnbWFwX3dyaXRlKGFkdjc1MTEtPnJlZ21hcCwg QURWNzUxMV9SRUdfQ1RTX01BTlVBTDIsCisJCSAgICAgY3RzICYgMHhmZik7CisKKwlyZXR1cm4g MDsKK30KKworaW50IGFkdjc1MTFfaGRtaV9od19wYXJhbXMoc3RydWN0IGRldmljZSAqZGV2LCB2 b2lkICpkYXRhLAorCQkJCXN0cnVjdCBoZG1pX2NvZGVjX2RhaWZtdCAqZm10LAorCQkJCXN0cnVj dCBoZG1pX2NvZGVjX3BhcmFtcyAqaHBhcm1zKQoreworCXN0cnVjdCBhZHY3NTExICphZHY3NTEx ID0gZGV2X2dldF9kcnZkYXRhKGRldik7CisJdW5zaWduZWQgaW50IGF1ZGlvX3NvdXJjZSwgaTJz X2Zvcm1hdCA9IDA7CisJdW5zaWduZWQgaW50IGludmVydF9jbG9jazsKKwl1bnNpZ25lZCBpbnQg cmF0ZTsKKwl1bnNpZ25lZCBpbnQgbGVuOworCisJc3dpdGNoIChocGFybXMtPnNhbXBsZV9yYXRl KSB7CisJY2FzZSAzMjAwMDoKKwkJcmF0ZSA9IEFEVjc1MTFfU0FNUExFX0ZSRVFfMzIwMDA7CisJ CWJyZWFrOworCWNhc2UgNDQxMDA6CisJCXJhdGUgPSBBRFY3NTExX1NBTVBMRV9GUkVRXzQ0MTAw OworCQlicmVhazsKKwljYXNlIDQ4MDAwOgorCQlyYXRlID0gQURWNzUxMV9TQU1QTEVfRlJFUV80 ODAwMDsKKwkJYnJlYWs7CisJY2FzZSA4ODIwMDoKKwkJcmF0ZSA9IEFEVjc1MTFfU0FNUExFX0ZS RVFfODgyMDA7CisJCWJyZWFrOworCWNhc2UgOTYwMDA6CisJCXJhdGUgPSBBRFY3NTExX1NBTVBM RV9GUkVRXzk2MDAwOworCQlicmVhazsKKwljYXNlIDE3NjQwMDoKKwkJcmF0ZSA9IEFEVjc1MTFf U0FNUExFX0ZSRVFfMTc2NDAwOworCQlicmVhazsKKwljYXNlIDE5MjAwMDoKKwkJcmF0ZSA9IEFE Vjc1MTFfU0FNUExFX0ZSRVFfMTkyMDAwOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlyZXR1cm4g LUVJTlZBTDsKKwl9CisKKwlzd2l0Y2ggKGhwYXJtcy0+c2FtcGxlX3dpZHRoKSB7CisJY2FzZSAx NjoKKwkJbGVuID0gQURWNzUxMV9JMlNfU0FNUExFX0xFTl8xNjsKKwkJYnJlYWs7CisJY2FzZSAx ODoKKwkJbGVuID0gQURWNzUxMV9JMlNfU0FNUExFX0xFTl8xODsKKwkJYnJlYWs7CisJY2FzZSAy MDoKKwkJbGVuID0gQURWNzUxMV9JMlNfU0FNUExFX0xFTl8yMDsKKwkJYnJlYWs7CisJY2FzZSAy NDoKKwkJbGVuID0gQURWNzUxMV9JMlNfU0FNUExFX0xFTl8yNDsKKwkJYnJlYWs7CisJZGVmYXVs dDoKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJc3dpdGNoIChmbXQtPmZtdCkgeworCWNhc2Ug SERNSV9JMlM6CisJCWF1ZGlvX3NvdXJjZSA9IEFEVjc1MTFfQVVESU9fU09VUkNFX0kyUzsKKwkJ aTJzX2Zvcm1hdCA9IEFEVjc1MTFfSTJTX0ZPUk1BVF9JMlM7CisJCWJyZWFrOworCWNhc2UgSERN SV9SSUdIVF9KOgorCQlhdWRpb19zb3VyY2UgPSBBRFY3NTExX0FVRElPX1NPVVJDRV9JMlM7CisJ CWkyc19mb3JtYXQgPSBBRFY3NTExX0kyU19GT1JNQVRfUklHSFRfSjsKKwkJYnJlYWs7CisJY2Fz ZSBIRE1JX0xFRlRfSjoKKwkJYXVkaW9fc291cmNlID0gQURWNzUxMV9BVURJT19TT1VSQ0VfSTJT OworCQlpMnNfZm9ybWF0ID0gQURWNzUxMV9JMlNfRk9STUFUX0xFRlRfSjsKKwkJYnJlYWs7CisJ ZGVmYXVsdDoKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJaW52ZXJ0X2Nsb2NrID0gZm10LT5i aXRfY2xrX2ludjsKKworCXJlZ21hcF91cGRhdGVfYml0cyhhZHY3NTExLT5yZWdtYXAsIEFEVjc1 MTFfUkVHX0FVRElPX1NPVVJDRSwgMHg3MCwKKwkJCSAgIGF1ZGlvX3NvdXJjZSA8PCA0KTsKKwly ZWdtYXBfdXBkYXRlX2JpdHMoYWR2NzUxMS0+cmVnbWFwLCBBRFY3NTExX1JFR19BVURJT19DT05G SUcsIEJJVCg2KSwKKwkJCSAgIGludmVydF9jbG9jayA8PCA2KTsKKwlyZWdtYXBfdXBkYXRlX2Jp dHMoYWR2NzUxMS0+cmVnbWFwLCBBRFY3NTExX1JFR19JMlNfQ09ORklHLCAweDAzLAorCQkJICAg aTJzX2Zvcm1hdCk7CisKKwlhZHY3NTExLT5hdWRpb19zb3VyY2UgPSBhdWRpb19zb3VyY2U7CisK KwlhZHY3NTExLT5mX2F1ZGlvID0gaHBhcm1zLT5zYW1wbGVfcmF0ZTsKKworCWFkdjc1MTFfdXBk YXRlX2N0c19uKGFkdjc1MTEpOworCisJcmVnbWFwX3VwZGF0ZV9iaXRzKGFkdjc1MTEtPnJlZ21h cCwgQURWNzUxMV9SRUdfQVVESU9fQ0ZHMywKKwkJCSAgIEFEVjc1MTFfQVVESU9fQ0ZHM19MRU5f TUFTSywgbGVuKTsKKwlyZWdtYXBfdXBkYXRlX2JpdHMoYWR2NzUxMS0+cmVnbWFwLCBBRFY3NTEx X1JFR19JMkNfRlJFUV9JRF9DRkcsCisJCQkgICBBRFY3NTExX0kyQ19GUkVRX0lEX0NGR19SQVRF X01BU0ssIHJhdGUgPDwgNCk7CisJcmVnbWFwX3dyaXRlKGFkdjc1MTEtPnJlZ21hcCwgMHg3Mywg MHgxKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGF1ZGlvX3N0YXJ0dXAoc3RydWN0 IGRldmljZSAqZGV2LCB2b2lkICpkYXRhKQoreworCXN0cnVjdCBhZHY3NTExICphZHY3NTExID0g ZGV2X2dldF9kcnZkYXRhKGRldik7CisKKwlyZWdtYXBfdXBkYXRlX2JpdHMoYWR2NzUxMS0+cmVn bWFwLCBBRFY3NTExX1JFR19BVURJT19DT05GSUcsCisJCQkJQklUKDcpLCAwKTsKKworCS8qIGhp ZGUgQXVkaW8gaW5mb2ZyYW1lIHVwZGF0ZXMgKi8KKwlyZWdtYXBfdXBkYXRlX2JpdHMoYWR2NzUx MS0+cmVnbWFwLCBBRFY3NTExX1JFR19JTkZPRlJBTUVfVVBEQVRFLAorCQkJCUJJVCg1KSwgQklU KDUpKTsKKwkvKiBlbmFibGUgTi9DVFMsIGVuYWJsZSBBdWRpbyBzYW1wbGUgcGFja2V0cyAqLwor CXJlZ21hcF91cGRhdGVfYml0cyhhZHY3NTExLT5yZWdtYXAsIEFEVjc1MTFfUkVHX1BBQ0tFVF9F TkFCTEUxLAorCQkJCUJJVCg1KSwgQklUKDUpKTsKKwkvKiBlbmFibGUgTi9DVFMgKi8KKwlyZWdt YXBfdXBkYXRlX2JpdHMoYWR2NzUxMS0+cmVnbWFwLCBBRFY3NTExX1JFR19QQUNLRVRfRU5BQkxF MSwKKwkJCQlCSVQoNiksIEJJVCg2KSk7CisJLyogbm90IGNvcHlyaWdodGVkICovCisJcmVnbWFw X3VwZGF0ZV9iaXRzKGFkdjc1MTEtPnJlZ21hcCwgQURWNzUxMV9SRUdfQVVESU9fQ0ZHMSwKKwkJ CQlCSVQoNSksIEJJVCg1KSk7CisJLyogZW5hYmxlIGF1ZGlvIGluZm9mcmFtZXMgKi8KKwlyZWdt YXBfdXBkYXRlX2JpdHMoYWR2NzUxMS0+cmVnbWFwLCBBRFY3NTExX1JFR19QQUNLRVRfRU5BQkxF MSwKKwkJCQlCSVQoMyksIEJJVCgzKSk7CisJLyogQVYgbXV0ZSBkaXNhYmxlICovCisJcmVnbWFw X3VwZGF0ZV9iaXRzKGFkdjc1MTEtPnJlZ21hcCwgQURWNzUxMV9SRUdfR0MoMCksCisJCQkJQklU KDcpIHwgQklUKDYpLCBCSVQoNykpOworCS8qIHVzZSBBdWRpbyBpbmZvZnJhbWUgdXBkYXRlZCBp bmZvICovCisJcmVnbWFwX3VwZGF0ZV9iaXRzKGFkdjc1MTEtPnJlZ21hcCwgQURWNzUxMV9SRUdf R0MoMSksCisJCQkJQklUKDUpLCAwKTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgYXVk aW9fc2h1dGRvd24oc3RydWN0IGRldmljZSAqZGV2LCB2b2lkICpkYXRhKQoreworfQorCitzdGF0 aWMgY29uc3Qgc3RydWN0IGhkbWlfY29kZWNfb3BzIGFkdjc1MTFfY29kZWNfb3BzID0geworCS5o d19wYXJhbXMJPSBhZHY3NTExX2hkbWlfaHdfcGFyYW1zLAorCS5hdWRpb19zaHV0ZG93biA9IGF1 ZGlvX3NodXRkb3duLAorCS5hdWRpb19zdGFydHVwCT0gYXVkaW9fc3RhcnR1cCwKK307CisKK3N0 YXRpYyBzdHJ1Y3QgaGRtaV9jb2RlY19wZGF0YSBjb2RlY19kYXRhID0geworCS5vcHMgPSAmYWR2 NzUxMV9jb2RlY19vcHMsCisJLm1heF9pMnNfY2hhbm5lbHMgPSAyLAorCS5pMnMgPSAxLAorfTsK KworaW50IGFkdjc1MTFfYXVkaW9faW5pdChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBhZHY3 NTExICphZHY3NTExKQoreworCWFkdjc1MTEtPmF1ZGlvX3BkZXYgPSBwbGF0Zm9ybV9kZXZpY2Vf cmVnaXN0ZXJfZGF0YShkZXYsCisJCQkJCUhETUlfQ09ERUNfRFJWX05BTUUsCisJCQkJCVBMQVRG T1JNX0RFVklEX0FVVE8sCisJCQkJCSZjb2RlY19kYXRhLAorCQkJCQlzaXplb2YoY29kZWNfZGF0 YSkpOworCXJldHVybiBQVFJfRVJSX09SX1pFUk8oYWR2NzUxMS0+YXVkaW9fcGRldik7Cit9CisK K3ZvaWQgYWR2NzUxMV9hdWRpb19leGl0KHN0cnVjdCBhZHY3NTExICphZHY3NTExKQoreworCWlm IChhZHY3NTExLT5hdWRpb19wZGV2KSB7CisJCXBsYXRmb3JtX2RldmljZV91bnJlZ2lzdGVyKGFk djc1MTEtPmF1ZGlvX3BkZXYpOworCQlhZHY3NTExLT5hdWRpb19wZGV2ID0gTlVMTDsKKwl9Cit9 CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYnJpZGdlL2Fkdjc1MTEvYWR2NzUxMV9kcnYu YyBiL2RyaXZlcnMvZ3B1L2RybS9icmlkZ2UvYWR2NzUxMS9hZHY3NTExX2Rydi5jCmluZGV4IDhl ZDM5MDYuLjhkYmE3MjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9icmlkZ2UvYWR2NzUx MS9hZHY3NTExX2Rydi5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9icmlkZ2UvYWR2NzUxMS9hZHY3 NTExX2Rydi5jCkBAIC0xMDM3LDYgKzEwMzcsOCBAQCBzdGF0aWMgaW50IGFkdjc1MTFfcHJvYmUo c3RydWN0IGkyY19jbGllbnQgKmkyYywgY29uc3Qgc3RydWN0IGkyY19kZXZpY2VfaWQgKmlkKQog CQlnb3RvIGVycl91bnJlZ2lzdGVyX2NlYzsKIAl9CiAKKwlhZHY3NTExX2F1ZGlvX2luaXQoZGV2 LCBhZHY3NTExKTsKKwogCXJldHVybiAwOwogCiBlcnJfdW5yZWdpc3Rlcl9jZWM6CkBAIC0xMDU4 LDYgKzEwNjAsOCBAQCBzdGF0aWMgaW50IGFkdjc1MTFfcmVtb3ZlKHN0cnVjdCBpMmNfY2xpZW50 ICppMmMpCiAKIAlkcm1fYnJpZGdlX3JlbW92ZSgmYWR2NzUxMS0+YnJpZGdlKTsKIAorCWFkdjc1 MTFfYXVkaW9fZXhpdChhZHY3NTExKTsKKwogCWkyY191bnJlZ2lzdGVyX2RldmljZShhZHY3NTEx LT5pMmNfZWRpZCk7CiAKIAlrZnJlZShhZHY3NTExLT5lZGlkKTsKLS0gCjIuNy40CgpfX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGlu ZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVl ZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK