From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751662AbcHLCHC (ORCPT ); Thu, 11 Aug 2016 22:07:02 -0400 Received: from regular1.263xmail.com ([211.150.99.138]:58305 "EHLO regular1.263xmail.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751257AbcHLCG6 (ORCPT ); Thu, 11 Aug 2016 22:06:58 -0400 X-263anti-spam: KSV:0; X-MAIL-GRAY: 0 X-MAIL-DELIVERY: 1 X-KSVirus-check: 0 X-ABS-CHECKED: 4 addr_info_check: 0 X-RL-SENDER: mark.yao@rock-chips.com X-FST-TO: linux-arm-kernel@lists.infradead.org X-SENDER-IP: 58.22.7.114 X-LOGIN-NAME: mark.yao@rock-chips.com X-UNIQUE-TAG: <0dc0f00074ba1271bfc5a3f68bbe5796> X-ATTACHMENT-NUM: 0 X-DNS-TYPE: 0 Subject: Re: [v10.1 PATCH 5/5] drm/rockchip: cdn-dp: add cdn DP support for rk3399 To: Chris Zhong , dianders@chromium.org, tfiga@chromium.org, heiko@sntech.de, yzq@rock-chips.com, groeck@chromium.org, myungjoo.ham@samsung.com, cw00.choi@samsung.com, wulf@rock-chips.com, marcheu@chromium.org References: <1470785557-21974-6-git-send-email-zyw@rock-chips.com> <1470871932-17419-1-git-send-email-zyw@rock-chips.com> Cc: linux-rockchip@lists.infradead.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, airlied@linux.ie, linux-arm-kernel@lists.infradead.org From: Mark yao Message-ID: <57AD2F30.9050408@rock-chips.com> Date: Fri, 12 Aug 2016 10:06:40 +0800 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:38.0) Gecko/20100101 Thunderbird/38.3.0 MIME-Version: 1.0 In-Reply-To: <1470871932-17419-1-git-send-email-zyw@rock-chips.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hi Chris Looks good for me only tiny problem comment inline. Thanks. On 2016年08月11日 07:32, Chris Zhong wrote: > Add support for cdn DP controller which is embedded in the rk3399 > SoCs. The DP is compliant with DisplayPort Specification, > Version 1.3, This IP is compatible with the rockchip type-c PHY IP. > There is a uCPU in DP controller, it need a firmware to work, > please put the firmware file to /lib/firmware/rockchip/dptx.bin. The > uCPU in charge of aux communication and link training, the host use > mailbox to communicate with the ucpu. > The dclk pin_pol of vop must not be invert for DP. > > Signed-off-by: Chris Zhong > Reviewed-by: Sean Paul > Acked-by: Mark Yao > > --- > > Changes in v10.1: > - support read sink count from DPCD > > Changes in v10: > - control the grf_clk in DP > > Changes in v9: > - do not need reset the phy before power_on > - add a orientation information for set_capability > - retry to read dpcd in 10 seconds > > Changes in v8: > - optimization the err log > > Changes in v7: > - support firmware standby when no dptx connection > - optimization the calculation of tu size and valid symbol > > Changes in v6: > - add a port struct > - select SND_SOC_HDMI_CODEC > - force reset the phy when hpd detected > > Changes in v5: > - alphabetical order > - do not use long, use u32 or u64 > - return MODE_CLOCK_HIGH when requested > actual > - Optimized Coding Style > - add a formula to get better tu size and symbol value. > - modify according to Sean Paul's comments > - fixed the fw_wait always 0 > > Changes in v4: > - use phy framework to control DP phy > - support 2 phys > > Changes in v3: > - use EXTCON_DISP_DP and EXTCON_DISP_DP_ALT cable to get dp port state. > - reset spdif before config it > - modify the firmware clk to 100Mhz > - retry load firmware if fw file is requested too early > > Changes in v2: > - Alphabetic order > - remove excess error message > - use define clk_rate > - check all return value > - remove dev_set_name(dp->dev, "cdn-dp"); > - use schedule_delayed_work > - remove never-called functions > - remove some unnecessary () > > Changes in v1: > - use extcon API > - use hdmi-codec for the DP Asoc > - do not initialize the "ret" > - printk a err log when drm_of_encoder_active_endpoint_id > - modify the dclk pin_pol to a single line > > drivers/gpu/drm/rockchip/Kconfig | 10 + > drivers/gpu/drm/rockchip/Makefile | 1 + > drivers/gpu/drm/rockchip/cdn-dp-core.c | 937 +++++++++++++++++++++++++++ > drivers/gpu/drm/rockchip/cdn-dp-core.h | 104 +++ > drivers/gpu/drm/rockchip/cdn-dp-reg.c | 959 ++++++++++++++++++++++++++++ > drivers/gpu/drm/rockchip/cdn-dp-reg.h | 482 ++++++++++++++ > drivers/gpu/drm/rockchip/rockchip_drm_vop.c | 13 +- > drivers/gpu/drm/rockchip/rockchip_drm_vop.h | 9 + > drivers/gpu/drm/rockchip/rockchip_vop_reg.c | 2 + > 9 files changed, 2514 insertions(+), 3 deletions(-) > create mode 100644 drivers/gpu/drm/rockchip/cdn-dp-core.c > create mode 100644 drivers/gpu/drm/rockchip/cdn-dp-core.h > create mode 100644 drivers/gpu/drm/rockchip/cdn-dp-reg.c > create mode 100644 drivers/gpu/drm/rockchip/cdn-dp-reg.h > > diff --git a/drivers/gpu/drm/rockchip/Kconfig b/drivers/gpu/drm/rockchip/Kconfig > index d30bdc3..20aaafe 100644 > --- a/drivers/gpu/drm/rockchip/Kconfig > +++ b/drivers/gpu/drm/rockchip/Kconfig > @@ -25,6 +25,16 @@ config ROCKCHIP_ANALOGIX_DP > for the Analogix Core DP driver. If you want to enable DP > on RK3288 based SoC, you should selet this option. > > +config ROCKCHIP_CDN_DP > + tristate "Rockchip cdn DP" > + depends on DRM_ROCKCHIP > + select SND_SOC_HDMI_CODEC if SND_SOC > + help > + This selects support for Rockchip SoC specific extensions > + for the cdn DP driver. If you want to enable Dp on > + RK3399 based SoC, you should select this > + option. > + > config ROCKCHIP_DW_HDMI > tristate "Rockchip specific extensions for Synopsys DW HDMI" > depends on DRM_ROCKCHIP > diff --git a/drivers/gpu/drm/rockchip/Makefile b/drivers/gpu/drm/rockchip/Makefile > index 05d0713..abdecd5 100644 > --- a/drivers/gpu/drm/rockchip/Makefile > +++ b/drivers/gpu/drm/rockchip/Makefile > @@ -7,6 +7,7 @@ rockchipdrm-y := rockchip_drm_drv.o rockchip_drm_fb.o \ > rockchipdrm-$(CONFIG_DRM_FBDEV_EMULATION) += rockchip_drm_fbdev.o > > obj-$(CONFIG_ROCKCHIP_ANALOGIX_DP) += analogix_dp-rockchip.o > +obj-$(CONFIG_ROCKCHIP_CDN_DP) += cdn-dp-core.o cdn-dp-reg.o > obj-$(CONFIG_ROCKCHIP_DW_HDMI) += dw_hdmi-rockchip.o > obj-$(CONFIG_ROCKCHIP_DW_MIPI_DSI) += dw-mipi-dsi.o > obj-$(CONFIG_ROCKCHIP_INNO_HDMI) += inno_hdmi.o > diff --git a/drivers/gpu/drm/rockchip/cdn-dp-core.c b/drivers/gpu/drm/rockchip/cdn-dp-core.c > new file mode 100644 > index 0000000..f9a5afb > --- /dev/null > +++ b/drivers/gpu/drm/rockchip/cdn-dp-core.c > @@ -0,0 +1,937 @@ > +/* > + * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd > + * Author: Chris Zhong > + * > + * This software is licensed under the terms of the GNU General Public > + * License version 2, as published by the Free Software Foundation, and > + * may be copied, distributed, and modified under those terms. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include > +#include > + > +#include > + > +#include "cdn-dp-core.h" > +#include "cdn-dp-reg.h" > +#include "rockchip_drm_vop.h" > + > +#define connector_to_dp(c) \ > + container_of(c, struct cdn_dp_device, connector) > + > +#define encoder_to_dp(c) \ > + container_of(c, struct cdn_dp_device, encoder) > + > +/* dp grf register offset */ > +#define GRF_SOC_CON9 0x6224 > +#define DP_SEL_VOP_LIT BIT(12) > +#define GRF_SOC_CON26 0x6268 > +#define UPHY_SEL_BIT 3 > +#define UPHY_SEL_MASK BIT(19) > +#define DPTX_HPD_SEL (3 << 12) > +#define DPTX_HPD_DEL (2 << 12) > +#define DPTX_HPD_SEL_MASK (3 << 28) > + > +#define MAX_FW_WAIT_SECS 64 > +#define CDN_DP_FIRMWARE "rockchip/dptx.bin" > + > +struct cdn_dp_data { > + u8 max_phy; > +}; > + > +struct cdn_dp_data rk3399_cdn_dp = { > + .max_phy = 2, > +}; > + > +static const struct of_device_id cdn_dp_dt_ids[] = { > + { .compatible = "rockchip,rk3399-cdn-dp", > + .data = (void *)&rk3399_cdn_dp }, > + {} > +}; > + > +MODULE_DEVICE_TABLE(of, cdn_dp_dt_ids); > + > +static int cdn_dp_grf_write(struct cdn_dp_device *dp, > + unsigned int reg, unsigned int val) > +{ > + int ret; > + > + ret = clk_prepare_enable(dp->grf_clk); > + if (ret) { > + dev_err(dp->dev, "Failed to prepare_enable grf clock\n"); > + return ret; > + } > + > + ret = regmap_write(dp->grf, reg, val); > + if (ret) { > + dev_err(dp->dev, "Could not write to GRF: %d\n", ret); > + return ret; > + } > + > + clk_disable_unprepare(dp->grf_clk); > + > + return 0; > +} > + > +static int cdn_dp_clk_enable(struct cdn_dp_device *dp) > +{ > + int ret; > + u32 rate; > + > + ret = clk_prepare_enable(dp->pclk); > + if (ret < 0) { > + dev_err(dp->dev, "cannot enable dp pclk %d\n", ret); > + goto err_pclk; > + } > + > + ret = clk_prepare_enable(dp->core_clk); > + if (ret < 0) { > + dev_err(dp->dev, "cannot enable core_clk %d\n", ret); > + goto err_core_clk; > + } > + > + rate = clk_get_rate(dp->core_clk); > + if (rate < 0) { > + dev_err(dp->dev, "get clk rate failed: %d\n", rate); > + goto err_set_rate; > + } > + > + cdn_dp_set_fw_clk(dp, rate); > + > + return 0; > + > +err_set_rate: > + clk_disable_unprepare(dp->core_clk); > +err_core_clk: > + clk_disable_unprepare(dp->pclk); > +err_pclk: > + return ret; > +} > + > +static enum drm_connector_status > +cdn_dp_connector_detect(struct drm_connector *connector, bool force) > +{ > + struct cdn_dp_device *dp = connector_to_dp(connector); > + > + return dp->hpd_status; > +} > + > +static void cdn_dp_connector_destroy(struct drm_connector *connector) > +{ > + drm_connector_unregister(connector); > + drm_connector_cleanup(connector); > +} > + > +static struct drm_connector_funcs cdn_dp_atomic_connector_funcs = { > + .dpms = drm_atomic_helper_connector_dpms, > + .detect = cdn_dp_connector_detect, > + .destroy = cdn_dp_connector_destroy, > + .fill_modes = drm_helper_probe_single_connector_modes, > + .reset = drm_atomic_helper_connector_reset, > + .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, > + .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, > +}; > + > +static int cdn_dp_connector_get_modes(struct drm_connector *connector) > +{ > + struct cdn_dp_device *dp = connector_to_dp(connector); > + struct edid *edid; > + int ret = 0; > + > + edid = drm_do_get_edid(connector, cdn_dp_get_edid_block, dp); > + if (edid) { > + dev_dbg(dp->dev, "got edid: width[%d] x height[%d]\n", > + edid->width_cm, edid->height_cm); > + > + dp->sink_has_audio = drm_detect_monitor_audio(edid); > + ret = drm_add_edid_modes(connector, edid); > + if (ret) { > + drm_mode_connector_update_edid_property(connector, > + edid); > + drm_edid_to_eld(connector, edid); > + } > + kfree(edid); > + } > + > + return ret; > +} > + > +static struct drm_encoder * > + cdn_dp_connector_best_encoder(struct drm_connector *connector) > +{ > + struct cdn_dp_device *dp = connector_to_dp(connector); > + > + return &dp->encoder; > +} I think cdn-dp have a 1:1 relationship between connectors and encoders, Since the commit(c61b93f drm/atomic: Fix remaining places where !funcs->best_encoder is valid), the best_encoder ops can be removed. > + > +static int cdn_dp_connector_mode_valid(struct drm_connector *connector, > + struct drm_display_mode *mode) > +{ > + struct cdn_dp_device *dp = connector_to_dp(connector); > + struct drm_display_info *display_info = &dp->connector.display_info; > + u32 requested = mode->clock * display_info->bpc * 3 / 1000; > + u32 actual, rate, sink_max, source_max = 0; > + u8 lanes, i; > + > + /* find the running port */ > + for (i = 0; i < dp->ports; i++) { > + if (dp->port[i]->phy_status) { > + source_max = dp->port[i]->cap_lanes; > + break; > + } > + } > + > + sink_max = drm_dp_max_lane_count(dp->dpcd); > + lanes = min(source_max, sink_max); > + > + source_max = drm_dp_bw_code_to_link_rate(CDN_DP_MAX_LINK_RATE); > + sink_max = drm_dp_max_link_rate(dp->dpcd); > + rate = min(source_max, sink_max); > + > + actual = rate * lanes / 100; > + > + /* efficiency is about 0.8 */ > + actual = actual * 8 / 10; > + > + if (requested > actual) { > + dev_dbg(dp->dev, "requested=%d, actual=%d, clock=%d\n", > + requested, actual, mode->clock); > + return MODE_CLOCK_HIGH; > + } > + > + return MODE_OK; > +} > + > +static struct drm_connector_helper_funcs cdn_dp_connector_helper_funcs = { > + .get_modes = cdn_dp_connector_get_modes, > + .best_encoder = cdn_dp_connector_best_encoder, > + .mode_valid = cdn_dp_connector_mode_valid, > +}; > + > +static void cdn_dp_commit(struct drm_encoder *encoder) > +{ > + struct cdn_dp_device *dp = encoder_to_dp(encoder); > + int ret; > + > + ret = cdn_dp_training_start(dp); > + if (ret) > + return; > + > + ret = cdn_dp_get_training_status(dp); > + if (ret) > + return; > + > + dev_info(dp->dev, "rate:0x%x, lanes:%d\n", > + dp->link.rate, dp->link.num_lanes); > + > + if (cdn_dp_set_video_status(dp, CONTROL_VIDEO_IDLE)) > + return; > + > + if (cdn_dp_config_video(dp)) > + return; > + > + if (cdn_dp_set_video_status(dp, CONTROL_VIDEO_VALID)) > + return; > + > + dp->dpms_mode = DRM_MODE_DPMS_ON; > +} > + > +static void cdn_dp_encoder_mode_set(struct drm_encoder *encoder, > + struct drm_display_mode *mode, > + struct drm_display_mode *adjusted) > +{ > + struct cdn_dp_device *dp = encoder_to_dp(encoder); > + struct drm_display_info *display_info = &dp->connector.display_info; > + struct rockchip_crtc_state *state; > + struct video_info *video = &dp->video_info; > + int ret, val; > + > + switch (display_info->bpc) { > + case 16: > + case 12: > + case 10: > + video->color_depth = 10; > + break; > + case 6: > + video->color_depth = 6; > + break; > + default: > + video->color_depth = 8; > + break; > + } > + > + video->color_fmt = PXL_RGB; > + > + video->v_sync_polarity = !!(mode->flags & DRM_MODE_FLAG_NVSYNC); > + video->h_sync_polarity = !!(mode->flags & DRM_MODE_FLAG_NHSYNC); > + > + ret = drm_of_encoder_active_endpoint_id(dp->dev->of_node, encoder); > + if (ret < 0) { > + dev_err(dp->dev, "Could not get vop id, %d", ret); > + return; > + } > + > + dev_dbg(dp->dev, "vop %s output to cdn-dp\n", (ret) ? "LIT" : "BIG"); > + state = to_rockchip_crtc_state(encoder->crtc->state); > + if (ret) { > + val = DP_SEL_VOP_LIT | (DP_SEL_VOP_LIT << 16); > + state->output_mode = ROCKCHIP_OUT_MODE_P888; > + } else { > + val = DP_SEL_VOP_LIT << 16; > + state->output_mode = ROCKCHIP_OUT_MODE_AAAA; > + } > + > + ret = cdn_dp_grf_write(dp, GRF_SOC_CON9, val); > + if (ret) > + return; > + > + memcpy(&dp->mode, adjusted, sizeof(*mode)); > +} > + > +static void cdn_dp_encoder_enable(struct drm_encoder *encoder) > +{ > + struct cdn_dp_device *dp = encoder_to_dp(encoder); > + > + if (dp->dpms_mode != DRM_MODE_DPMS_ON) > + cdn_dp_commit(encoder); > +} > + > +static void cdn_dp_encoder_disable(struct drm_encoder *encoder) > +{ > + struct cdn_dp_device *dp = encoder_to_dp(encoder); > + > + dp->dpms_mode = DRM_MODE_DPMS_OFF; > +} > + > +static int > +cdn_dp_encoder_atomic_check(struct drm_encoder *encoder, > + struct drm_crtc_state *crtc_state, > + struct drm_connector_state *conn_state) > +{ > + struct rockchip_crtc_state *s = to_rockchip_crtc_state(crtc_state); > + > + s->output_mode = ROCKCHIP_OUT_MODE_AAAA; > + s->output_type = DRM_MODE_CONNECTOR_DisplayPort; > + > + return 0; > +} > + > +static struct drm_encoder_helper_funcs cdn_dp_encoder_helper_funcs = { > + .mode_set = cdn_dp_encoder_mode_set, > + .enable = cdn_dp_encoder_enable, > + .disable = cdn_dp_encoder_disable, > + .atomic_check = cdn_dp_encoder_atomic_check, > +}; > + > +static struct drm_encoder_funcs cdn_dp_encoder_funcs = { > + .destroy = drm_encoder_cleanup, > +}; > + > +static int cdn_dp_firmware_init(struct cdn_dp_device *dp) > +{ > + int ret; > + const u32 *iram_data, *dram_data; > + const struct firmware *fw = dp->fw; > + const struct cdn_firmware_header *hdr; > + > + hdr = (struct cdn_firmware_header *)fw->data; > + if (fw->size != le32_to_cpu(hdr->size_bytes)) { > + dev_err(dp->dev, "firmware is invalid\n"); > + return -EINVAL; > + } > + > + iram_data = (const u32 *)(fw->data + hdr->header_size); > + dram_data = (const u32 *)(fw->data + hdr->header_size + hdr->iram_size); > + > + ret = cdn_dp_load_firmware(dp, iram_data, hdr->iram_size, > + dram_data, hdr->dram_size); > + if (ret) > + return ret; > + > + ret = cdn_dp_set_firmware_active(dp, true); > + if (ret) { > + dev_err(dp->dev, "active ucpu failed: %d\n", ret); > + return ret; > + } > + > + return cdn_dp_event_config(dp); > +} > + > +static int cdn_dp_init(struct cdn_dp_device *dp) > +{ > + struct device *dev = dp->dev; > + struct device_node *np = dev->of_node; > + struct platform_device *pdev = to_platform_device(dev); > + struct resource *res; > + int ret; > + > + dp->grf = syscon_regmap_lookup_by_phandle(np, "rockchip,grf"); > + if (IS_ERR(dp->grf)) { > + dev_err(dev, "cdn-dp needs rockchip,grf property\n"); > + return PTR_ERR(dp->grf); > + } > + > + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); > + dp->regs = devm_ioremap_resource(dev, res); > + if (IS_ERR(dp->regs)) { > + dev_err(dev, "ioremap reg failed\n"); > + return PTR_ERR(dp->regs); > + } > + > + dp->core_clk = devm_clk_get(dev, "core-clk"); > + if (IS_ERR(dp->core_clk)) { > + dev_err(dev, "cannot get core_clk_dp\n"); > + return PTR_ERR(dp->core_clk); > + } > + > + dp->pclk = devm_clk_get(dev, "pclk"); > + if (IS_ERR(dp->pclk)) { > + dev_err(dev, "cannot get pclk\n"); > + return PTR_ERR(dp->pclk); > + } > + > + dp->spdif_clk = devm_clk_get(dev, "spdif"); > + if (IS_ERR(dp->spdif_clk)) { > + dev_err(dev, "cannot get spdif_clk\n"); > + return PTR_ERR(dp->spdif_clk); > + } > + > + dp->grf_clk = devm_clk_get(dev, "grf"); > + if (IS_ERR(dp->grf_clk)) { > + dev_err(dev, "cannot get grf clk\n"); > + return PTR_ERR(dp->grf_clk); > + } > + > + dp->spdif_rst = devm_reset_control_get(dev, "spdif"); > + if (IS_ERR(dp->spdif_rst)) { > + dev_err(dev, "no spdif reset control found\n"); > + return PTR_ERR(dp->spdif_rst); > + } > + > + dp->dpms_mode = DRM_MODE_DPMS_OFF; > + > + ret = cdn_dp_clk_enable(dp); > + if (ret < 0) > + return ret; > + > + cdn_dp_clock_reset(dp); > + > + return 0; > +} > + > +static int cdn_dp_audio_hw_params(struct device *dev, void *data, > + struct hdmi_codec_daifmt *daifmt, > + struct hdmi_codec_params *params) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + struct audio_info audio = { > + .sample_width = params->sample_width, > + .sample_rate = params->sample_rate, > + .channels = params->channels, > + }; > + int ret; > + > + if (!dp->encoder.crtc) > + return -ENODEV; > + > + switch (daifmt->fmt) { > + case HDMI_I2S: > + audio.format = AFMT_I2S; > + break; > + case HDMI_SPDIF: > + audio.format = AFMT_SPDIF; > + break; > + default: > + dev_err(dev, "%s: Invalid format %d\n", __func__, daifmt->fmt); > + return -EINVAL; > + } > + > + ret = cdn_dp_audio_config(dp, &audio); > + if (!ret) > + dp->audio_info = audio; > + > + return ret; > +} > + > +static void cdn_dp_audio_shutdown(struct device *dev, void *data) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + int ret; > + > + if (!dp->encoder.crtc) > + return; > + > + ret = cdn_dp_audio_stop(dp, &dp->audio_info); > + if (!ret) > + dp->audio_info.format = AFMT_UNUSED; > +} > + > +static int cdn_dp_audio_digital_mute(struct device *dev, void *data, > + bool enable) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + > + if (!dp->encoder.crtc) > + return -ENODEV; > + > + return cdn_dp_audio_mute(dp, enable); > +} > + > +static int cdn_dp_audio_get_eld(struct device *dev, void *data, > + u8 *buf, size_t len) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + struct drm_mode_config *config = &dp->encoder.dev->mode_config; > + struct drm_connector *connector; > + int ret = -ENODEV; > + > + mutex_lock(&config->mutex); > + list_for_each_entry(connector, &config->connector_list, head) { > + if (&dp->encoder == connector->encoder) { > + memcpy(buf, connector->eld, > + min(sizeof(connector->eld), len)); > + ret = 0; > + } > + } > + mutex_unlock(&config->mutex); > + > + return ret; > +} > + > +static const struct hdmi_codec_ops audio_codec_ops = { > + .hw_params = cdn_dp_audio_hw_params, > + .audio_shutdown = cdn_dp_audio_shutdown, > + .digital_mute = cdn_dp_audio_digital_mute, > + .get_eld = cdn_dp_audio_get_eld, > +}; > + > +static int cdn_dp_audio_codec_init(struct cdn_dp_device *dp, > + struct device *dev) > +{ > + struct hdmi_codec_pdata codec_data = { > + .i2s = 1, > + .spdif = 1, > + .ops = &audio_codec_ops, > + .max_i2s_channels = 8, > + }; > + > + dp->audio_pdev = platform_device_register_data( > + dev, HDMI_CODEC_DRV_NAME, PLATFORM_DEVID_AUTO, > + &codec_data, sizeof(codec_data)); > + > + return PTR_ERR_OR_ZERO(dp->audio_pdev); > +} > + > +static int cdn_dp_get_cap_lanes(struct cdn_dp_device *dp, > + struct extcon_dev *edev) > +{ > + bool dfp, dptx; > + u8 lanes; > + > + dfp = extcon_get_state(edev, EXTCON_USB_HOST); > + dptx = extcon_get_state(edev, EXTCON_DISP_DP); > + > + if (dfp && dptx) > + lanes = 2; > + else if (dptx) > + lanes = 4; > + else > + lanes = 0; > + > + return lanes; > +} > + > +static int cdn_dp_pd_event(struct notifier_block *nb, > + unsigned long event, void *priv) > +{ > + struct cdn_dp_port *port; > + > + port = container_of(nb, struct cdn_dp_port, event_nb); > + > + schedule_delayed_work(&port->event_wq, 0); > + > + return 0; > +} > + > +static void cdn_dp_pd_event_wq(struct work_struct *work) > +{ > + struct cdn_dp_port *port = container_of(work, struct cdn_dp_port, > + event_wq.work); > + union extcon_property_value property; > + struct cdn_dp_device *dp = port->dp; > + u8 new_cap_lanes, sink_count, i; > + int ret; > + > + new_cap_lanes = cdn_dp_get_cap_lanes(dp, port->extcon); > + > + if (new_cap_lanes == port->cap_lanes) { > + dev_dbg(dp->dev, "lanes count does not change: %d\n", > + new_cap_lanes); > + > + if (!new_cap_lanes) > + return; > + > + /* > + * Read the sink count from DPCD, if sink count become 0, this > + * phy could be power off. > + */ > + ret = cdn_dp_dpcd_read(dp, DP_SINK_COUNT, > + &sink_count, 1); ret = cdn_dp_dpcd_read(dp, DP_SINK_COUNT, &sink_count, 1); this line is not over 80 characters, no need to become two lines. > + if (ret || sink_count) > + return; > + > + new_cap_lanes = 0; > + } > + > + if (!new_cap_lanes) { > + ret = phy_power_off(port->phy); > + if (ret) { > + dev_err(dp->dev, "phy power off failed: %d", ret); > + return; > + } > + port->phy_status = false; > + port->cap_lanes = 0; > + for (i = 0; i < dp->ports; i++) { > + if (dp->port[i]->phy_status) > + return; > + } > + > + ret = cdn_dp_grf_write(dp, GRF_SOC_CON26, > + DPTX_HPD_SEL_MASK | DPTX_HPD_DEL); > + if (ret) > + return; > + > + dp->hpd_status = connector_status_disconnected; > + drm_helper_hpd_irq_event(dp->drm_dev); > + cdn_dp_set_firmware_active(dp, false); > + return; > + } > + > + /* if other phy is running, do not touch the hpd_status, and return */ > + for (i = 0; i < dp->ports; i++) { > + if (dp->port[i]->phy_status) { > + dev_warn(dp->dev, "busy, phy[%d] is running", > + dp->port[i]->id); > + return; > + } > + } > + > + if (!dp->fw_loaded) { > + ret = request_firmware(&dp->fw, CDN_DP_FIRMWARE, dp->dev); > + if (ret == -ENOENT && dp->fw_wait <= MAX_FW_WAIT_SECS) { > + unsigned long time = msecs_to_jiffies(dp->fw_wait * HZ); > + > + /* > + * If can not find the file, retry to load the firmware > + * in several seconds, if still failed after 1 minute, > + * give up. > + */ > + schedule_delayed_work(&port->event_wq, time); > + dp->fw_wait *= 2; > + return; > + } else if (ret) { > + dev_err(dp->dev, "failed to request firmware: %d\n", > + ret); > + return; > + } > + } else { > + cdn_dp_set_firmware_active(dp, true); > + } > + > + ret = cdn_dp_grf_write(dp, GRF_SOC_CON26, > + (port->id << UPHY_SEL_BIT) | UPHY_SEL_MASK); > + if (ret) > + goto err_phy; > + > + ret = phy_power_on(port->phy); > + if (ret) { > + dev_err(dp->dev, "phy power on failed: %d\n", ret); > + goto err_phy; > + } > + > + port->phy_status = true; > + > + if (!dp->fw_loaded) { > + ret = cdn_dp_firmware_init(dp); > + if (ret) { > + dev_err(dp->dev, "firmware init failed: %d", ret); > + goto err_firmware; > + } > + release_firmware(dp->fw); > + dp->fw_loaded = 1; > + } > + > + ret = cdn_dp_grf_write(dp, GRF_SOC_CON26, > + DPTX_HPD_SEL_MASK | DPTX_HPD_SEL); > + if (ret) > + goto err_firmware; > + > + ret = cdn_dp_get_hpd_status(dp); > + if (ret <= 0) { > + if (!ret) > + dev_err(dp->dev, "hpd does not exist\n"); > + goto err_firmware; > + } > + > + ret = extcon_get_property(port->extcon, EXTCON_DISP_DP, > + EXTCON_PROP_USB_TYPEC_POLARITY, &property); > + if (ret) { > + dev_err(dp->dev, "get property failed\n"); > + goto err_firmware; > + } > + > + ret = cdn_dp_set_host_cap(dp, new_cap_lanes, property.intval); > + if (ret) { > + dev_err(dp->dev, "set host capabilities failed: %d\n", ret); > + goto err_firmware; > + } > + > + /* > + * Native read with retry for link status and receiver capability reads > + * for cases where the sink may still not be ready. > + * > + * Sinks are *supposed* to come up within 1ms from an off state, but > + * some DOCKs need about 5 seconds to power up, so read the dpcd every > + * 100ms, if can not get a good dpcd in 10 seconds, give up. > + */ > + for (i = 0; i < 100; i++) { > + ret = cdn_dp_dpcd_read(dp, 0x000, dp->dpcd, > + DP_RECEIVER_CAP_SIZE); > + if (!ret) { > + dev_dbg(dp->dev, "get dpcd success!\n"); > + > + /* > + * Check sink count here. Then goto power off phy, > + * if sink count is 0. > + */ > + ret = cdn_dp_dpcd_read(dp, DP_SINK_COUNT, > + &sink_count, 1); > + if (ret) > + continue; > + > + sink_count = DP_GET_SINK_COUNT(sink_count); > + if (!sink_count) > + goto err_firmware; > + > + port->cap_lanes = new_cap_lanes; > + dp->hpd_status = connector_status_connected; > + drm_helper_hpd_irq_event(dp->drm_dev); > + return; > + } else if (!extcon_get_state(port->extcon, EXTCON_DISP_DP)) { > + break; > + } > + msleep(100); > + } > + > + dev_err(dp->dev, "get dpcd failed!\n"); > + > +err_firmware: > + ret = phy_power_off(port->phy); > + if (ret) > + dev_err(dp->dev, "phy power off failed: %d", ret); > + else > + port->phy_status = false; > + > +err_phy: > + if (dp->fw_loaded) > + cdn_dp_set_firmware_active(dp, false); > + else > + release_firmware(dp->fw); > +} > + > +static int cdn_dp_bind(struct device *dev, struct device *master, void *data) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + struct drm_encoder *encoder; > + struct drm_connector *connector; > + struct cdn_dp_port *port; > + struct drm_device *drm_dev = data; > + int ret, i; > + > + ret = cdn_dp_init(dp); > + if (ret < 0) > + return ret; > + > + dp->drm_dev = drm_dev; > + dp->hpd_status = connector_status_disconnected; > + dp->fw_wait = 1; > + > + encoder = &dp->encoder; > + > + encoder->possible_crtcs = drm_of_find_possible_crtcs(drm_dev, > + dev->of_node); > + DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder->possible_crtcs); > + > + ret = drm_encoder_init(drm_dev, encoder, &cdn_dp_encoder_funcs, > + DRM_MODE_ENCODER_TMDS, NULL); > + if (ret) { > + DRM_ERROR("failed to initialize encoder with drm\n"); > + return ret; > + } > + > + drm_encoder_helper_add(encoder, &cdn_dp_encoder_helper_funcs); > + > + connector = &dp->connector; > + connector->polled = DRM_CONNECTOR_POLL_HPD; > + connector->dpms = DRM_MODE_DPMS_OFF; > + > + ret = drm_connector_init(drm_dev, connector, > + &cdn_dp_atomic_connector_funcs, > + DRM_MODE_CONNECTOR_DisplayPort); > + if (ret) { > + DRM_ERROR("failed to initialize connector with drm\n"); > + goto err_free_encoder; > + } > + > + drm_connector_helper_add(connector, &cdn_dp_connector_helper_funcs); > + > + ret = drm_mode_connector_attach_encoder(connector, encoder); > + if (ret) { > + DRM_ERROR("failed to attach connector and encoder\n"); > + goto err_free_connector; > + } > + > + cdn_dp_audio_codec_init(dp, dev); > + > + for (i = 0; i < dp->ports; i++) { > + port = dp->port[i]; > + > + port->event_nb.notifier_call = cdn_dp_pd_event; > + INIT_DELAYED_WORK(&port->event_wq, cdn_dp_pd_event_wq); > + ret = extcon_register_notifier(port->extcon, EXTCON_DISP_DP, > + &port->event_nb); > + if (ret) { > + dev_err(dev, "register EXTCON_DISP_DP notifier err\n"); > + return ret; > + } > + > + if (extcon_get_state(port->extcon, EXTCON_DISP_DP)) > + schedule_delayed_work(&port->event_wq, 0); > + } > + > + return 0; > + > +err_free_connector: > + drm_connector_cleanup(connector); > +err_free_encoder: > + drm_encoder_cleanup(encoder); > + return ret; > +} > + > +static void cdn_dp_unbind(struct device *dev, struct device *master, void *data) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + struct drm_encoder *encoder = &dp->encoder; > + struct drm_connector *connector = &dp->connector; > + struct cdn_dp_port *port; > + int i; > + > + platform_device_unregister(dp->audio_pdev); > + cdn_dp_encoder_disable(encoder); > + encoder->funcs->destroy(encoder); > + connector->funcs->destroy(connector); > + > + for (i = 0; i < dp->ports; i++) { > + port = dp->port[i]; > + extcon_unregister_notifier(port->extcon, EXTCON_DISP_DP, > + &port->event_nb); > + } > +} > + > +static const struct component_ops cdn_dp_component_ops = { > + .bind = cdn_dp_bind, > + .unbind = cdn_dp_unbind, > +}; > + > +static int cdn_dp_probe(struct platform_device *pdev) > +{ > + struct device *dev = &pdev->dev; > + const struct of_device_id *match; > + struct cdn_dp_data *dp_data; > + struct cdn_dp_port *port; > + struct cdn_dp_device *dp; > + struct extcon_dev *extcon; > + struct phy *phy; > + int i; > + > + dp = devm_kzalloc(dev, sizeof(*dp), GFP_KERNEL); > + if (!dp) > + return -ENOMEM; > + dp->dev = dev; > + > + match = of_match_node(cdn_dp_dt_ids, pdev->dev.of_node); > + dp_data = (struct cdn_dp_data *)match->data; > + > + for (i = 0; i < dp_data->max_phy; i++) { > + extcon = extcon_get_edev_by_phandle(dev, i); > + phy = devm_of_phy_get_by_index(dev, dev->of_node, i); > + > + if (PTR_ERR(extcon) == -EPROBE_DEFER || > + PTR_ERR(phy) == -EPROBE_DEFER) > + return -EPROBE_DEFER; > + > + if (IS_ERR(extcon) || IS_ERR(phy)) > + continue; > + > + port = devm_kzalloc(dev, sizeof(*port), GFP_KERNEL); > + if (!dp) > + return -ENOMEM; > + > + port->extcon = extcon; > + port->phy = phy; > + port->dp = dp; > + port->id = i; > + dp->port[dp->ports++] = port; > + } > + > + if (!dp->ports) { > + dev_err(dev, "missing extcon or phy\n"); > + return -EINVAL; > + } > + > + dev_set_drvdata(dev, dp); > + > + return component_add(dev, &cdn_dp_component_ops); > +} > + > +static int cdn_dp_remove(struct platform_device *pdev) > +{ > + component_del(&pdev->dev, &cdn_dp_component_ops); > + > + return 0; > +} > + > +static struct platform_driver cdn_dp_driver = { > + .probe = cdn_dp_probe, > + .remove = cdn_dp_remove, > + .driver = { > + .name = "cdn-dp", > + .owner = THIS_MODULE, > + .of_match_table = of_match_ptr(cdn_dp_dt_ids), > + }, > +}; > + > +module_platform_driver(cdn_dp_driver); > + > +MODULE_AUTHOR("Chris Zhong "); > +MODULE_DESCRIPTION("cdn DP Driver"); > +MODULE_LICENSE("GPL v2"); > diff --git a/drivers/gpu/drm/rockchip/cdn-dp-core.h b/drivers/gpu/drm/rockchip/cdn-dp-core.h > new file mode 100644 > index 0000000..0cf23db > --- /dev/null > +++ b/drivers/gpu/drm/rockchip/cdn-dp-core.h > @@ -0,0 +1,104 @@ > +/* > + * Copyright (C) 2016 Chris Zhong > + * Copyright (C) 2016 ROCKCHIP, Inc. > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation; either version 2 of the License. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + */ > + > +#ifndef _CDN_DP_CORE_H > +#define _CDN_DP_CORE_H > + > +#include > +#include > +#include > +#include > +#include "rockchip_drm_drv.h" > + > +#define MAX_PHY 2 > + > +enum audio_format { > + AFMT_I2S = 0, > + AFMT_SPDIF = 1, > + AFMT_UNUSED, > +}; > + > +struct audio_info { > + enum audio_format format; > + int sample_rate; > + int channels; > + int sample_width; > +}; > + > +enum vic_pxl_encoding_format { > + PXL_RGB = 0x1, > + YCBCR_4_4_4 = 0x2, > + YCBCR_4_2_2 = 0x4, > + YCBCR_4_2_0 = 0x8, > + Y_ONLY = 0x10, > +}; > + > +struct video_info { > + bool h_sync_polarity; > + bool v_sync_polarity; > + bool interlaced; > + int color_depth; > + enum vic_pxl_encoding_format color_fmt; > +}; > + > +struct cdn_firmware_header { > + u32 size_bytes; /* size of the entire header+image(s) in bytes */ > + u32 header_size; /* size of just the header in bytes */ > + u32 iram_size; /* size of iram */ > + u32 dram_size; /* size of dram */ > +}; > + > +struct cdn_dp_port { > + struct cdn_dp_device *dp; > + struct notifier_block event_nb; > + struct delayed_work event_wq; > + struct extcon_dev *extcon; > + struct phy *phy; > + u8 cap_lanes; > + bool phy_status; > + u8 id; > +}; > + > +struct cdn_dp_device { > + struct device *dev; > + struct drm_device *drm_dev; > + struct drm_connector connector; > + struct drm_encoder encoder; > + struct drm_display_mode mode; > + struct platform_device *audio_pdev; > + > + const struct firmware *fw; /* cdn dp firmware */ > + unsigned int fw_version; /* cdn fw version */ > + u32 fw_wait; > + bool fw_loaded; > + bool fw_actived; > + void __iomem *regs; > + struct regmap *grf; > + struct clk *core_clk; > + struct clk *pclk; > + struct clk *spdif_clk; > + struct clk *grf_clk; > + struct reset_control *spdif_rst; > + struct audio_info audio_info; > + struct video_info video_info; > + struct drm_dp_link link; > + struct cdn_dp_port *port[MAX_PHY]; > + u8 ports; > + > + u8 dpcd[DP_RECEIVER_CAP_SIZE]; > + enum drm_connector_status hpd_status; > + int dpms_mode; > + bool sink_has_audio; > +}; > +#endif /* _CDN_DP_CORE_H */ > diff --git a/drivers/gpu/drm/rockchip/cdn-dp-reg.c b/drivers/gpu/drm/rockchip/cdn-dp-reg.c > new file mode 100644 > index 0000000..2ea702d > --- /dev/null > +++ b/drivers/gpu/drm/rockchip/cdn-dp-reg.c > @@ -0,0 +1,959 @@ > +/* > + * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd > + * Author: Chris Zhong > + * > + * This software is licensed under the terms of the GNU General Public > + * License version 2, as published by the Free Software Foundation, and > + * may be copied, distributed, and modified under those terms. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include "cdn-dp-core.h" > +#include "cdn-dp-reg.h" > + > +#define CDN_DP_SPDIF_CLK 200000000 > +#define FW_ALIVE_TIMEOUT_US 1000000 > +#define MAILBOX_RETRY_US 1000 > +#define MAILBOX_TIMEOUT_US 5000000 > +#define LINK_TRAINING_RETRY_MS 20 > +#define LINK_TRAINING_TIMEOUT_MS 500 > + > +void cdn_dp_set_fw_clk(struct cdn_dp_device *dp, u32 clk) > +{ > + writel(clk / 1000000, dp->regs + SW_CLK_H); > +} > + > +void cdn_dp_clock_reset(struct cdn_dp_device *dp) > +{ > + u32 val; > + > + val = DPTX_FRMR_DATA_CLK_RSTN_EN | > + DPTX_FRMR_DATA_CLK_EN | > + DPTX_PHY_DATA_RSTN_EN | > + DPTX_PHY_DATA_CLK_EN | > + DPTX_PHY_CHAR_RSTN_EN | > + DPTX_PHY_CHAR_CLK_EN | > + SOURCE_AUX_SYS_CLK_RSTN_EN | > + SOURCE_AUX_SYS_CLK_EN | > + DPTX_SYS_CLK_RSTN_EN | > + DPTX_SYS_CLK_EN | > + CFG_DPTX_VIF_CLK_RSTN_EN | > + CFG_DPTX_VIF_CLK_EN; > + writel(val, dp->regs + SOURCE_DPTX_CAR); > + > + val = SOURCE_PHY_RSTN_EN | SOURCE_PHY_CLK_EN; > + writel(val, dp->regs + SOURCE_PHY_CAR); > + > + val = SOURCE_PKT_SYS_RSTN_EN | > + SOURCE_PKT_SYS_CLK_EN | > + SOURCE_PKT_DATA_RSTN_EN | > + SOURCE_PKT_DATA_CLK_EN; > + writel(val, dp->regs + SOURCE_PKT_CAR); > + > + val = SPDIF_CDR_CLK_RSTN_EN | > + SPDIF_CDR_CLK_EN | > + SOURCE_AIF_SYS_RSTN_EN | > + SOURCE_AIF_SYS_CLK_EN | > + SOURCE_AIF_CLK_RSTN_EN | > + SOURCE_AIF_CLK_EN; > + writel(val, dp->regs + SOURCE_AIF_CAR); > + > + val = SOURCE_CIPHER_SYSTEM_CLK_RSTN_EN | > + SOURCE_CIPHER_SYS_CLK_EN | > + SOURCE_CIPHER_CHAR_CLK_RSTN_EN | > + SOURCE_CIPHER_CHAR_CLK_EN; > + writel(val, dp->regs + SOURCE_CIPHER_CAR); > + > + val = SOURCE_CRYPTO_SYS_CLK_RSTN_EN | > + SOURCE_CRYPTO_SYS_CLK_EN; > + writel(val, dp->regs + SOURCE_CRYPTO_CAR); > + > + val = ~(MAILBOX_INT_MASK_BIT | PIF_INT_MASK_BIT) & ALL_INT_MASK; > + writel(val, dp->regs + APB_INT_MASK); > +} > + > +static int cdn_dp_mailbox_read(struct cdn_dp_device *dp, bool force) > +{ > + int val, ret; > + > + if (!dp->fw_actived && !force) > + return -EPERM; > + > + ret = readx_poll_timeout(readl, dp->regs + MAILBOX_EMPTY_ADDR, > + val, !val, MAILBOX_RETRY_US, > + MAILBOX_TIMEOUT_US); > + if (ret < 0) > + return ret; > + > + return readl(dp->regs + MAILBOX0_RD_DATA) & 0xff; > +} > + > +static int cdp_dp_mailbox_write(struct cdn_dp_device *dp, u8 val, bool force) > +{ > + int ret, full; > + > + if (!dp->fw_actived && !force) > + return -EPERM; > + > + ret = readx_poll_timeout(readl, dp->regs + MAILBOX_FULL_ADDR, > + full, !full, MAILBOX_RETRY_US, > + MAILBOX_TIMEOUT_US); > + if (ret < 0) > + return ret; > + > + writel(val, dp->regs + MAILBOX0_WR_DATA); > + > + return 0; > +} > + > +static int cdn_dp_mailbox_validate_receive(struct cdn_dp_device *dp, > + u8 module_id, u8 opcode, > + u8 req_size) > +{ > + u32 mbox_size, i; > + u8 header[4]; > + int ret; > + > + /* read the header of the message */ > + for (i = 0; i < 4; i++) { > + ret = cdn_dp_mailbox_read(dp, 0); > + if (ret < 0) > + return ret; > + > + header[i] = ret; > + } > + > + mbox_size = (header[2] << 8) | header[3]; > + > + if (opcode != header[0] || module_id != header[1] || > + req_size != mbox_size) { > + /* > + * If the message in mailbox is not what we want, we need to > + * clear the mailbox by read. > + */ > + for (i = 0; i < mbox_size; i++) > + if (cdn_dp_mailbox_read(dp, 0) < 0) > + break; > + > + return -EINVAL; > + } > + > + return 0; > +} > + > +static int cdn_dp_mailbox_read_receive(struct cdn_dp_device *dp, > + u8 *buff, u8 buff_size) > +{ > + u32 i; > + int ret; > + > + for (i = 0; i < buff_size; i++) { > + ret = cdn_dp_mailbox_read(dp, 0); > + if (ret < 0) > + return ret; > + > + buff[i] = ret; > + } > + > + return 0; > +} > + > +static int cdn_dp_mailbox_send(struct cdn_dp_device *dp, u8 module_id, > + u8 opcode, u16 size, u8 *message) > +{ > + u8 header[4]; > + int ret, i; > + > + header[0] = opcode; > + header[1] = module_id; > + header[2] = (size >> 8) & 0xff; > + header[3] = size & 0xff; > + > + for (i = 0; i < 4; i++) { > + ret = cdp_dp_mailbox_write(dp, header[i], 0); > + if (ret) > + return ret; > + } > + > + for (i = 0; i < size; i++) { > + ret = cdp_dp_mailbox_write(dp, message[i], 0); > + if (ret) > + return ret; > + } > + > + return 0; > +} > + > +static int cdn_dp_reg_write(struct cdn_dp_device *dp, u16 addr, u32 val) > +{ > + u8 msg[6]; > + > + msg[0] = (addr >> 8) & 0xff; > + msg[1] = addr & 0xff; > + msg[2] = (val >> 24) & 0xff; > + msg[3] = (val >> 16) & 0xff; > + msg[4] = (val >> 8) & 0xff; > + msg[5] = val & 0xff; > + return cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_WRITE_REGISTER, > + sizeof(msg), msg); > +} > + > +static int cdn_dp_reg_write_bit(struct cdn_dp_device *dp, u16 addr, > + u8 start_bit, u8 bits_no, u32 val) > +{ > + u8 field[8]; > + > + field[0] = (addr >> 8) & 0xff; > + field[1] = addr & 0xff; > + field[2] = start_bit; > + field[3] = bits_no; > + field[4] = (val >> 24) & 0xff; > + field[5] = (val >> 16) & 0xff; > + field[6] = (val >> 8) & 0xff; > + field[7] = val & 0xff; > + > + return cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_WRITE_FIELD, > + sizeof(field), field); > +} > + > +int cdn_dp_dpcd_read(struct cdn_dp_device *dp, u32 addr, u8 *data, u16 len) > +{ > + u8 msg[5], reg[5]; > + int ret; > + > + msg[0] = (len >> 8) & 0xff; > + msg[1] = len & 0xff; > + msg[2] = (addr >> 16) & 0xff; > + msg[3] = (addr >> 8) & 0xff; > + msg[4] = addr & 0xff; > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_READ_DPCD, > + sizeof(msg), msg); > + if (ret) > + goto err_dpcd_read; > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_READ_DPCD, > + sizeof(reg) + len); > + if (ret) > + goto err_dpcd_read; > + > + ret = cdn_dp_mailbox_read_receive(dp, reg, sizeof(reg)); > + if (ret) > + goto err_dpcd_read; > + > + ret = cdn_dp_mailbox_read_receive(dp, data, len); > + > +err_dpcd_read: > + return ret; > +} > + > +int cdn_dp_dpcd_write(struct cdn_dp_device *dp, u32 addr, u8 value) > +{ > + u8 msg[6], reg[5]; > + int ret; > + > + msg[0] = 0; > + msg[1] = 1; > + msg[2] = (addr >> 16) & 0xff; > + msg[3] = (addr >> 8) & 0xff; > + msg[4] = addr & 0xff; > + msg[5] = value; > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_WRITE_DPCD, > + sizeof(msg), msg); > + if (ret) > + goto err_dpcd_write; > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_WRITE_DPCD, sizeof(reg)); > + if (ret) > + goto err_dpcd_write; > + > + ret = cdn_dp_mailbox_read_receive(dp, reg, sizeof(reg)); > + if (ret) > + goto err_dpcd_write; > + > + if (addr != (reg[2] << 16 | reg[3] << 8 | reg[4])) > + ret = -EINVAL; > + > +err_dpcd_write: > + if (ret) > + dev_err(dp->dev, "dpcd write failed: %d\n", ret); > + return ret; > +} > + > +int cdn_dp_load_firmware(struct cdn_dp_device *dp, const u32 *i_mem, > + u32 i_size, const u32 *d_mem, u32 d_size) > +{ > + u32 reg; > + int i, ret; > + > + /* reset ucpu before load firmware*/ > + writel(APB_IRAM_PATH | APB_DRAM_PATH | APB_XT_RESET, > + dp->regs + APB_CTRL); > + > + for (i = 0; i < i_size; i += 4) > + writel(*i_mem++, dp->regs + ADDR_IMEM + i); > + > + for (i = 0; i < d_size; i += 4) > + writel(*d_mem++, dp->regs + ADDR_DMEM + i); > + > + /* un-reset ucpu */ > + writel(0, dp->regs + APB_CTRL); > + > + /* check the keep alive register to make sure fw working */ > + ret = readx_poll_timeout(readl, dp->regs + KEEP_ALIVE, > + reg, reg, 2000, FW_ALIVE_TIMEOUT_US); > + if (ret < 0) { > + dev_err(dp->dev, "failed to loaded the FW reg = %x\n", reg); > + return -EINVAL; > + } > + > + reg = readl(dp->regs + VER_L) & 0xff; > + dp->fw_version = reg; > + reg = readl(dp->regs + VER_H) & 0xff; > + dp->fw_version |= reg << 8; > + reg = readl(dp->regs + VER_LIB_L_ADDR) & 0xff; > + dp->fw_version |= reg << 16; > + reg = readl(dp->regs + VER_LIB_H_ADDR) & 0xff; > + dp->fw_version |= reg << 24; > + > + dev_dbg(dp->dev, "firmware version: %x\n", dp->fw_version); > + > + return 0; > +} > + > +int cdn_dp_set_firmware_active(struct cdn_dp_device *dp, bool enable) > +{ > + u8 msg[5]; > + int ret, i; > + > + msg[0] = GENERAL_MAIN_CONTROL; > + msg[1] = MB_MODULE_ID_GENERAL; > + msg[2] = 0; > + msg[3] = 1; > + msg[4] = enable ? FW_ACTIVE : FW_STANDBY; > + > + for (i = 0; i < sizeof(msg); i++) { > + ret = cdp_dp_mailbox_write(dp, msg[i], 1); > + if (ret) > + goto err_set_firmware_active; > + } > + > + /* read the firmware state */ > + for (i = 0; i < sizeof(msg); i++) { > + ret = cdn_dp_mailbox_read(dp, 1); > + if (ret < 0) > + goto err_set_firmware_active; > + > + msg[i] = ret; > + } > + > + dp->fw_actived = (msg[4] == FW_ACTIVE); > + ret = 0; > + > +err_set_firmware_active: > + if (ret < 0) > + dev_err(dp->dev, "set firmware active failed\n"); > + return ret; > +} > + > +int cdn_dp_set_host_cap(struct cdn_dp_device *dp, u8 lanes, bool flip) > +{ > + u8 msg[8]; > + int ret; > + > + msg[0] = CDN_DP_MAX_LINK_RATE; > + msg[1] = lanes; > + msg[2] = VOLTAGE_LEVEL_2; > + msg[3] = PRE_EMPHASIS_LEVEL_3; > + msg[4] = PTS1 | PTS2 | PTS3 | PTS4; > + msg[5] = FAST_LT_NOT_SUPPORT; > + msg[6] = flip ? LANE_MAPPING_FLIPPED : LANE_MAPPING_NORMAL; > + msg[7] = ENHANCED; > + > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, > + DPTX_SET_HOST_CAPABILITIES, > + sizeof(msg), msg); > + if (ret) > + goto err_set_host_cap; > + > + ret = cdn_dp_reg_write(dp, DP_AUX_SWAP_INVERSION_CONTROL, > + AUX_HOST_INVERT); > + > +err_set_host_cap: > + if (ret) > + dev_err(dp->dev, "set host cap failed: %d\n", ret); > + return ret; > +} > + > +int cdn_dp_event_config(struct cdn_dp_device *dp) > +{ > + u8 msg[5]; > + int ret; > + > + memset(msg, 0, sizeof(msg)); > + > + msg[0] = DPTX_EVENT_ENABLE_HPD | DPTX_EVENT_ENABLE_TRAINING; > + > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_ENABLE_EVENT, > + sizeof(msg), msg); > + if (ret) > + dev_err(dp->dev, "set event config failed: %d\n", ret); > + > + return ret; > +} > + > +u32 cdn_dp_get_event(struct cdn_dp_device *dp) > +{ > + return readl(dp->regs + SW_EVENTS0); > +} > + > +int cdn_dp_get_hpd_status(struct cdn_dp_device *dp) > +{ > + u8 status; > + int ret; > + > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_HPD_STATE, > + 0, NULL); > + if (ret) > + goto err_get_hpd; > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_HPD_STATE, sizeof(status)); > + if (ret) > + goto err_get_hpd; > + > + ret = cdn_dp_mailbox_read_receive(dp, &status, sizeof(status)); > + if (ret) > + goto err_get_hpd; > + > + return status; > + > +err_get_hpd: > + dev_err(dp->dev, "get hpd status failed: %d\n", ret); > + return ret; > +} > + > +int cdn_dp_get_edid_block(void *data, u8 *edid, > + unsigned int block, size_t length) > +{ > + struct cdn_dp_device *dp = data; > + u8 msg[2], reg[2]; > + int ret; > + > + msg[0] = block / 2; > + msg[1] = block % 2; > + > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_GET_EDID, > + sizeof(msg), msg); > + if (ret) > + goto err_get_edid; > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_GET_EDID, > + sizeof(reg) + length); > + if (ret) > + goto err_get_edid; > + > + ret = cdn_dp_mailbox_read_receive(dp, reg, sizeof(reg)); > + if (ret) > + goto err_get_edid; > + > + ret = cdn_dp_mailbox_read_receive(dp, edid, length); > + if (ret) > + goto err_get_edid; > + > + if (reg[0] != length || reg[1] != block / 2) > + ret = -EINVAL; > + > +err_get_edid: > + if (ret) > + dev_err(dp->dev, "get block[%d] edid failed: %d\n", block, ret); > + return ret; > +} > + > +int cdn_dp_training_start(struct cdn_dp_device *dp) > +{ > + unsigned long timeout; > + u8 msg, event[2]; > + int ret; > + > + msg = LINK_TRAINING_RUN; > + > + /* start training */ > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_TRAINING_CONTROL, > + sizeof(msg), &msg); > + if (ret) > + goto err_training_start; > + > + timeout = jiffies + msecs_to_jiffies(LINK_TRAINING_TIMEOUT_MS); > + while (time_before(jiffies, timeout)) { > + msleep(LINK_TRAINING_RETRY_MS); > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, > + DPTX_READ_EVENT, 0, NULL); > + if (ret) > + goto err_training_start; > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_READ_EVENT, > + sizeof(event)); > + if (ret) > + goto err_training_start; > + > + ret = cdn_dp_mailbox_read_receive(dp, event, sizeof(event)); > + if (ret) > + goto err_training_start; > + > + if (event[1] & EQ_PHASE_FINISHED) > + return 0; > + } > + > + ret = -ETIMEDOUT; > + > +err_training_start: > + dev_err(dp->dev, "training failed: %d\n", ret); > + return ret; > +} > + > +int cdn_dp_get_training_status(struct cdn_dp_device *dp) > +{ > + u8 status[10]; > + int ret; > + > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_READ_LINK_STAT, > + 0, NULL); > + if (ret) > + goto err_get_training_status; > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_READ_LINK_STAT, > + sizeof(status)); > + if (ret) > + goto err_get_training_status; > + > + ret = cdn_dp_mailbox_read_receive(dp, status, sizeof(status)); > + if (ret) > + goto err_get_training_status; > + > + dp->link.rate = status[0]; > + dp->link.num_lanes = status[1]; > + > +err_get_training_status: > + if (ret) > + dev_err(dp->dev, "get training status failed: %d\n", ret); > + return ret; > +} > + > +int cdn_dp_set_video_status(struct cdn_dp_device *dp, int active) > +{ > + u8 msg; > + int ret; > + > + msg = !!active; > + > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_SET_VIDEO, > + sizeof(msg), &msg); > + if (ret) > + dev_err(dp->dev, "set video status failed: %d\n", ret); > + > + return ret; > +} > + > +static int cdn_dp_get_msa_misc(struct video_info *video, > + struct drm_display_mode *mode) > +{ > + u32 msa_misc; > + u8 val[2]; > + > + switch (video->color_fmt) { > + case PXL_RGB: > + case Y_ONLY: > + val[0] = 0; > + break; > + /* set YUV default color space conversion to BT601 */ > + case YCBCR_4_4_4: > + val[0] = 6 + BT_601 * 8; > + break; > + case YCBCR_4_2_2: > + val[0] = 5 + BT_601 * 8; > + break; > + case YCBCR_4_2_0: > + val[0] = 5; > + break; > + }; > + > + switch (video->color_depth) { > + case 6: > + val[1] = 0; > + break; > + case 8: > + val[1] = 1; > + break; > + case 10: > + val[1] = 2; > + break; > + case 12: > + val[1] = 3; > + break; > + case 16: > + val[1] = 4; > + break; > + }; > + > + msa_misc = 2 * val[0] + 32 * val[1] + > + ((video->color_fmt == Y_ONLY) ? (1 << 14) : 0); > + > + return msa_misc; > +} > + > +int cdn_dp_config_video(struct cdn_dp_device *dp) > +{ > + struct video_info *video = &dp->video_info; > + struct drm_display_mode *mode = &dp->mode; > + u64 symbol, tmp; > + u32 val, link_rate; > + u8 bit_per_pix, tu_size_reg = TU_SIZE; > + int ret; > + > + bit_per_pix = (video->color_fmt == YCBCR_4_2_2) ? > + (video->color_depth * 2) : (video->color_depth * 3); > + > + link_rate = drm_dp_bw_code_to_link_rate(dp->link.rate) / 1000; > + > + val = VIF_BYPASS_INTERLACE; > + ret = cdn_dp_reg_write(dp, BND_HSYNC2VSYNC, val); > + if (ret) > + goto err_config_video; > + > + ret = cdn_dp_reg_write(dp, HSYNC2VSYNC_POL_CTRL, 0); > + if (ret) > + goto err_config_video; > + > + /* > + * get a best tu_size and valid symbol: > + * 1. chose Lclk freq(162Mhz, 270Mhz, 540Mhz), set TU to 32 > + * 2. calculate VS(valid symbol) = TU * Pclk * Bpp / (Lclk * Lanes) > + * 3. if VS > *.85 or VS < *.1 or VS < 2 or TU < VS + 4, then set > + * TU += 2 and repeat 2nd step. > + */ > + do { > + tu_size_reg += 2; > + tmp = tu_size_reg * mode->clock * bit_per_pix; > + tmp /= dp->link.num_lanes * link_rate * 8; > + symbol = tmp / 1000; > + } while ((symbol <= 1) || (tu_size_reg - symbol < 4) || > + (tmp % 1000 > 850) || (tmp % 1000 < 100)); > + > + val = symbol + (tu_size_reg << 8); > + ret = cdn_dp_reg_write(dp, DP_FRAMER_TU, val); > + if (ret) > + goto err_config_video; > + > + /* set the FIFO Buffer size */ > + val = ((mode->clock * (symbol + 1) / 1000) + link_rate); > + val /= (dp->link.num_lanes * link_rate); > + val = 8 * (symbol + 1) / bit_per_pix - val; > + val += 2; > + ret = cdn_dp_reg_write(dp, DP_VC_TABLE(15), val); > + > + switch (video->color_depth) { > + case 6: > + val = BCS_6; > + break; > + case 8: > + val = BCS_8; > + break; > + case 10: > + val = BCS_10; > + break; > + case 12: > + val = BCS_12; > + break; > + case 16: > + val = BCS_16; > + break; > + }; > + > + val += video->color_fmt << 8; > + ret = cdn_dp_reg_write(dp, DP_FRAMER_PXL_REPR, val); > + if (ret) > + goto err_config_video; > + > + val = video->h_sync_polarity ? DP_FRAMER_SP_HSP : 0; > + val |= video->v_sync_polarity ? DP_FRAMER_SP_VSP : 0; > + ret = cdn_dp_reg_write(dp, DP_FRAMER_SP, val); > + if (ret) > + goto err_config_video; > + > + val = (mode->hsync_start - mode->hdisplay) << 16; > + val |= mode->htotal - mode->hsync_end; > + ret = cdn_dp_reg_write(dp, DP_FRONT_BACK_PORCH, val); > + if (ret) > + goto err_config_video; > + > + val = mode->hdisplay * bit_per_pix / 8; > + ret = cdn_dp_reg_write(dp, DP_BYTE_COUNT, val); > + if (ret) > + goto err_config_video; > + > + val = mode->htotal | ((mode->htotal - mode->hsync_start) << 16); > + ret = cdn_dp_reg_write(dp, MSA_HORIZONTAL_0, val); > + if (ret) > + goto err_config_video; > + > + val = mode->hsync_end - mode->hsync_start; > + val |= (mode->hdisplay << 16) | (video->h_sync_polarity << 15); > + ret = cdn_dp_reg_write(dp, MSA_HORIZONTAL_1, val); > + if (ret) > + goto err_config_video; > + > + val = mode->vtotal; > + val |= ((mode->vtotal - mode->vsync_start) << 16); > + ret = cdn_dp_reg_write(dp, MSA_VERTICAL_0, val); > + if (ret) > + goto err_config_video; > + > + val = mode->vsync_end - mode->vsync_start; > + val |= mode->vdisplay << 16 | (video->v_sync_polarity << 15); > + ret = cdn_dp_reg_write(dp, MSA_VERTICAL_1, val); > + if (ret) > + goto err_config_video; > + > + val = cdn_dp_get_msa_misc(video, mode); > + ret = cdn_dp_reg_write(dp, MSA_MISC, val); > + if (ret) > + goto err_config_video; > + > + ret = cdn_dp_reg_write(dp, STREAM_CONFIG, 1); > + if (ret) > + goto err_config_video; > + > + val = mode->hsync_end - mode->hsync_start; > + val |= (mode->hdisplay << 16); > + ret = cdn_dp_reg_write(dp, DP_HORIZONTAL, val); > + if (ret) > + goto err_config_video; > + > + val = mode->vtotal; > + val -= (mode->vtotal - mode->vdisplay); > + val |= (mode->vtotal - mode->vsync_start) << 16; > + ret = cdn_dp_reg_write(dp, DP_VERTICAL_0, val); > + if (ret) > + goto err_config_video; > + > + val = mode->vtotal; > + ret = cdn_dp_reg_write(dp, DP_VERTICAL_1, val); > + if (ret) > + goto err_config_video; > + > + val = 0; > + ret = cdn_dp_reg_write_bit(dp, DP_VB_ID, 2, 1, val); > + > +err_config_video: > + if (ret) > + dev_err(dp->dev, "config video failed: %d\n", ret); > + return ret; > +} > + > +int cdn_dp_audio_stop(struct cdn_dp_device *dp, struct audio_info *audio) > +{ > + u32 val; > + int ret; > + > + ret = cdn_dp_reg_write(dp, AUDIO_PACK_CONTROL, 0); > + if (ret) { > + dev_err(dp->dev, "audio stop failed: %d\n", ret); > + return ret; > + } > + > + val = SPDIF_AVG_SEL | SPDIF_JITTER_BYPASS; > + val |= SPDIF_FIFO_MID_RANGE(0xe0); > + val |= SPDIF_JITTER_THRSH(0xe0); > + val |= SPDIF_JITTER_AVG_WIN(7); > + writel(val, dp->regs + SPDIF_CTRL_ADDR); > + > + /* clearn the audio config and reset */ > + writel(0, dp->regs + AUDIO_SRC_CNTL); > + writel(0, dp->regs + AUDIO_SRC_CNFG); > + writel(AUDIO_SW_RST, dp->regs + AUDIO_SRC_CNTL); > + writel(0, dp->regs + AUDIO_SRC_CNTL); > + > + /* reset smpl2pckt component */ > + writel(0, dp->regs + SMPL2PKT_CNTL); > + writel(AUDIO_SW_RST, dp->regs + SMPL2PKT_CNTL); > + writel(0, dp->regs + SMPL2PKT_CNTL); > + > + /* reset FIFO */ > + writel(AUDIO_SW_RST, dp->regs + FIFO_CNTL); > + writel(0, dp->regs + FIFO_CNTL); > + > + if (audio->format == AFMT_SPDIF) > + clk_disable_unprepare(dp->spdif_clk); > + > + return 0; > +} > + > +int cdn_dp_audio_mute(struct cdn_dp_device *dp, bool enable) > +{ > + int ret; > + > + ret = cdn_dp_reg_write_bit(dp, DP_VB_ID, 4, 1, enable); > + if (ret) > + dev_err(dp->dev, "audio mute failed: %d\n", ret); > + > + return ret; > +} > + > +static void cdn_dp_audio_config_i2s(struct cdn_dp_device *dp, > + struct audio_info *audio) > +{ > + int sub_pckt_num = 1, i2s_port_en_val = 0xf, i; > + u32 val; > + > + if (audio->channels == 2) { > + if (dp->link.num_lanes == 1) > + sub_pckt_num = 2; > + else > + sub_pckt_num = 4; > + > + i2s_port_en_val = 1; > + } else if (audio->channels == 4) { > + i2s_port_en_val = 3; > + } > + > + writel(0x0, dp->regs + SPDIF_CTRL_ADDR); > + > + writel(SYNC_WR_TO_CH_ZERO, dp->regs + FIFO_CNTL); > + > + val = MAX_NUM_CH(audio->channels); > + val |= NUM_OF_I2S_PORTS(audio->channels); > + val |= AUDIO_TYPE_LPCM; > + val |= CFG_SUB_PCKT_NUM(sub_pckt_num); > + writel(val, dp->regs + SMPL2PKT_CNFG); > + > + if (audio->sample_width == 16) > + val = 0; > + else if (audio->sample_width == 24) > + val = 1 << 9; > + else > + val = 2 << 9; > + > + val |= AUDIO_CH_NUM(audio->channels); > + val |= I2S_DEC_PORT_EN(i2s_port_en_val); > + val |= TRANS_SMPL_WIDTH_32; > + writel(val, dp->regs + AUDIO_SRC_CNFG); > + > + for (i = 0; i < (audio->channels + 1) / 2; i++) { > + if (audio->sample_width == 16) > + val = (0x08 << 8) | (0x08 << 20); > + else if (audio->sample_width == 24) > + val = (0x0b << 8) | (0x0b << 20); > + > + val |= ((2 * i) << 4) | ((2 * i + 1) << 16); > + writel(val, dp->regs + STTS_BIT_CH(i)); > + } > + > + switch (audio->sample_rate) { > + case 32000: > + val = SAMPLING_FREQ(3) | > + ORIGINAL_SAMP_FREQ(0xc); > + break; > + case 44100: > + val = SAMPLING_FREQ(0) | > + ORIGINAL_SAMP_FREQ(0xf); > + break; > + case 48000: > + val = SAMPLING_FREQ(2) | > + ORIGINAL_SAMP_FREQ(0xd); > + break; > + case 88200: > + val = SAMPLING_FREQ(8) | > + ORIGINAL_SAMP_FREQ(0x7); > + break; > + case 96000: > + val = SAMPLING_FREQ(0xa) | > + ORIGINAL_SAMP_FREQ(5); > + break; > + case 176400: > + val = SAMPLING_FREQ(0xc) | > + ORIGINAL_SAMP_FREQ(3); > + break; > + case 192000: > + val = SAMPLING_FREQ(0xe) | > + ORIGINAL_SAMP_FREQ(1); > + break; > + } > + val |= 4; > + writel(val, dp->regs + COM_CH_STTS_BITS); > + > + writel(SMPL2PKT_EN, dp->regs + SMPL2PKT_CNTL); > + writel(I2S_DEC_START, dp->regs + AUDIO_SRC_CNTL); > +} > + > +static void cdn_dp_audio_config_spdif(struct cdn_dp_device *dp) > +{ > + u32 val; > + > + val = SPDIF_AVG_SEL | SPDIF_JITTER_BYPASS; > + val |= SPDIF_FIFO_MID_RANGE(0xe0); > + val |= SPDIF_JITTER_THRSH(0xe0); > + val |= SPDIF_JITTER_AVG_WIN(7); > + writel(val, dp->regs + SPDIF_CTRL_ADDR); > + > + writel(SYNC_WR_TO_CH_ZERO, dp->regs + FIFO_CNTL); > + > + val = MAX_NUM_CH(2) | AUDIO_TYPE_LPCM | CFG_SUB_PCKT_NUM(4); > + writel(val, dp->regs + SMPL2PKT_CNFG); > + writel(SMPL2PKT_EN, dp->regs + SMPL2PKT_CNTL); > + > + val = SPDIF_ENABLE | SPDIF_AVG_SEL | SPDIF_JITTER_BYPASS; > + val |= SPDIF_FIFO_MID_RANGE(0xe0); > + val |= SPDIF_JITTER_THRSH(0xe0); > + val |= SPDIF_JITTER_AVG_WIN(7); > + writel(val, dp->regs + SPDIF_CTRL_ADDR); > + > + clk_prepare_enable(dp->spdif_clk); > + clk_set_rate(dp->spdif_clk, CDN_DP_SPDIF_CLK); > +} > + > +int cdn_dp_audio_config(struct cdn_dp_device *dp, struct audio_info *audio) > +{ > + int ret; > + > + /* reset the spdif clk before config */ > + if (audio->format == AFMT_SPDIF) { > + reset_control_assert(dp->spdif_rst); > + reset_control_deassert(dp->spdif_rst); > + } > + > + ret = cdn_dp_reg_write(dp, CM_LANE_CTRL, LANE_REF_CYC); > + if (ret) > + goto err_audio_config; > + > + ret = cdn_dp_reg_write(dp, CM_CTRL, 0); > + if (ret) > + goto err_audio_config; > + > + if (audio->format == AFMT_I2S) > + cdn_dp_audio_config_i2s(dp, audio); > + else > + cdn_dp_audio_config_spdif(dp); > + > + ret = cdn_dp_reg_write(dp, AUDIO_PACK_CONTROL, AUDIO_PACK_EN); > + > +err_audio_config: > + if (ret) > + dev_err(dp->dev, "audio config failed: %d\n", ret); > + return ret; > +} > diff --git a/drivers/gpu/drm/rockchip/cdn-dp-reg.h b/drivers/gpu/drm/rockchip/cdn-dp-reg.h > new file mode 100644 > index 0000000..6ac3674 > --- /dev/null > +++ b/drivers/gpu/drm/rockchip/cdn-dp-reg.h > @@ -0,0 +1,482 @@ > +/* > + * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd > + * Author: Chris Zhong > + * > + * This software is licensed under the terms of the GNU General Public > + * License version 2, as published by the Free Software Foundation, and > + * may be copied, distributed, and modified under those terms. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + */ > + > +#ifndef _CDN_DP_REG_H > +#define _CDN_DP_REG_H > + > +#include > + > +#define ADDR_IMEM 0x10000 > +#define ADDR_DMEM 0x20000 > + > +/* APB CFG addr */ > +#define APB_CTRL 0 > +#define XT_INT_CTRL 0x04 > +#define MAILBOX_FULL_ADDR 0x08 > +#define MAILBOX_EMPTY_ADDR 0x0c > +#define MAILBOX0_WR_DATA 0x10 > +#define MAILBOX0_RD_DATA 0x14 > +#define KEEP_ALIVE 0x18 > +#define VER_L 0x1c > +#define VER_H 0x20 > +#define VER_LIB_L_ADDR 0x24 > +#define VER_LIB_H_ADDR 0x28 > +#define SW_DEBUG_L 0x2c > +#define SW_DEBUG_H 0x30 > +#define MAILBOX_INT_MASK 0x34 > +#define MAILBOX_INT_STATUS 0x38 > +#define SW_CLK_L 0x3c > +#define SW_CLK_H 0x40 > +#define SW_EVENTS0 0x44 > +#define SW_EVENTS1 0x48 > +#define SW_EVENTS2 0x4c > +#define SW_EVENTS3 0x50 > +#define XT_OCD_CTRL 0x60 > +#define APB_INT_MASK 0x6c > +#define APB_STATUS_MASK 0x70 > + > +/* audio decoder addr */ > +#define AUDIO_SRC_CNTL 0x30000 > +#define AUDIO_SRC_CNFG 0x30004 > +#define COM_CH_STTS_BITS 0x30008 > +#define STTS_BIT_CH(x) (0x3000c + ((x) << 2)) > +#define SPDIF_CTRL_ADDR 0x3004c > +#define SPDIF_CH1_CS_3100_ADDR 0x30050 > +#define SPDIF_CH1_CS_6332_ADDR 0x30054 > +#define SPDIF_CH1_CS_9564_ADDR 0x30058 > +#define SPDIF_CH1_CS_12796_ADDR 0x3005c > +#define SPDIF_CH1_CS_159128_ADDR 0x30060 > +#define SPDIF_CH1_CS_191160_ADDR 0x30064 > +#define SPDIF_CH2_CS_3100_ADDR 0x30068 > +#define SPDIF_CH2_CS_6332_ADDR 0x3006c > +#define SPDIF_CH2_CS_9564_ADDR 0x30070 > +#define SPDIF_CH2_CS_12796_ADDR 0x30074 > +#define SPDIF_CH2_CS_159128_ADDR 0x30078 > +#define SPDIF_CH2_CS_191160_ADDR 0x3007c > +#define SMPL2PKT_CNTL 0x30080 > +#define SMPL2PKT_CNFG 0x30084 > +#define FIFO_CNTL 0x30088 > +#define FIFO_STTS 0x3008c > + > +/* source pif addr */ > +#define SOURCE_PIF_WR_ADDR 0x30800 > +#define SOURCE_PIF_WR_REQ 0x30804 > +#define SOURCE_PIF_RD_ADDR 0x30808 > +#define SOURCE_PIF_RD_REQ 0x3080c > +#define SOURCE_PIF_DATA_WR 0x30810 > +#define SOURCE_PIF_DATA_RD 0x30814 > +#define SOURCE_PIF_FIFO1_FLUSH 0x30818 > +#define SOURCE_PIF_FIFO2_FLUSH 0x3081c > +#define SOURCE_PIF_STATUS 0x30820 > +#define SOURCE_PIF_INTERRUPT_SOURCE 0x30824 > +#define SOURCE_PIF_INTERRUPT_MASK 0x30828 > +#define SOURCE_PIF_PKT_ALLOC_REG 0x3082c > +#define SOURCE_PIF_PKT_ALLOC_WR_EN 0x30830 > +#define SOURCE_PIF_SW_RESET 0x30834 > + > +/* bellow registers need access by mailbox */ > +/* source car addr */ > +#define SOURCE_HDTX_CAR 0x0900 > +#define SOURCE_DPTX_CAR 0x0904 > +#define SOURCE_PHY_CAR 0x0908 > +#define SOURCE_CEC_CAR 0x090c > +#define SOURCE_CBUS_CAR 0x0910 > +#define SOURCE_PKT_CAR 0x0918 > +#define SOURCE_AIF_CAR 0x091c > +#define SOURCE_CIPHER_CAR 0x0920 > +#define SOURCE_CRYPTO_CAR 0x0924 > + > +/* clock meters addr */ > +#define CM_CTRL 0x0a00 > +#define CM_I2S_CTRL 0x0a04 > +#define CM_SPDIF_CTRL 0x0a08 > +#define CM_VID_CTRL 0x0a0c > +#define CM_LANE_CTRL 0x0a10 > +#define I2S_NM_STABLE 0x0a14 > +#define I2S_NCTS_STABLE 0x0a18 > +#define SPDIF_NM_STABLE 0x0a1c > +#define SPDIF_NCTS_STABLE 0x0a20 > +#define NMVID_MEAS_STABLE 0x0a24 > +#define I2S_MEAS 0x0a40 > +#define SPDIF_MEAS 0x0a80 > +#define NMVID_MEAS 0x0ac0 > + > +/* source vif addr */ > +#define BND_HSYNC2VSYNC 0x0b00 > +#define HSYNC2VSYNC_F1_L1 0x0b04 > +#define HSYNC2VSYNC_F2_L1 0x0b08 > +#define HSYNC2VSYNC_STATUS 0x0b0c > +#define HSYNC2VSYNC_POL_CTRL 0x0b10 > + > +/* dptx phy addr */ > +#define DP_TX_PHY_CONFIG_REG 0x2000 > +#define DP_TX_PHY_STATUS_REG 0x2004 > +#define DP_TX_PHY_SW_RESET 0x2008 > +#define DP_TX_PHY_SCRAMBLER_SEED 0x200c > +#define DP_TX_PHY_TRAINING_01_04 0x2010 > +#define DP_TX_PHY_TRAINING_05_08 0x2014 > +#define DP_TX_PHY_TRAINING_09_10 0x2018 > +#define TEST_COR 0x23fc > + > +/* dptx hpd addr */ > +#define HPD_IRQ_DET_MIN_TIMER 0x2100 > +#define HPD_IRQ_DET_MAX_TIMER 0x2104 > +#define HPD_UNPLGED_DET_MIN_TIMER 0x2108 > +#define HPD_STABLE_TIMER 0x210c > +#define HPD_FILTER_TIMER 0x2110 > +#define HPD_EVENT_MASK 0x211c > +#define HPD_EVENT_DET 0x2120 > + > +/* dpyx framer addr */ > +#define DP_FRAMER_GLOBAL_CONFIG 0x2200 > +#define DP_SW_RESET 0x2204 > +#define DP_FRAMER_TU 0x2208 > +#define DP_FRAMER_PXL_REPR 0x220c > +#define DP_FRAMER_SP 0x2210 > +#define AUDIO_PACK_CONTROL 0x2214 > +#define DP_VC_TABLE(x) (0x2218 + ((x) << 2)) > +#define DP_VB_ID 0x2258 > +#define DP_MTPH_LVP_CONTROL 0x225c > +#define DP_MTPH_SYMBOL_VALUES 0x2260 > +#define DP_MTPH_ECF_CONTROL 0x2264 > +#define DP_MTPH_ACT_CONTROL 0x2268 > +#define DP_MTPH_STATUS 0x226c > +#define DP_INTERRUPT_SOURCE 0x2270 > +#define DP_INTERRUPT_MASK 0x2274 > +#define DP_FRONT_BACK_PORCH 0x2278 > +#define DP_BYTE_COUNT 0x227c > + > +/* dptx stream addr */ > +#define MSA_HORIZONTAL_0 0x2280 > +#define MSA_HORIZONTAL_1 0x2284 > +#define MSA_VERTICAL_0 0x2288 > +#define MSA_VERTICAL_1 0x228c > +#define MSA_MISC 0x2290 > +#define STREAM_CONFIG 0x2294 > +#define AUDIO_PACK_STATUS 0x2298 > +#define VIF_STATUS 0x229c > +#define PCK_STUFF_STATUS_0 0x22a0 > +#define PCK_STUFF_STATUS_1 0x22a4 > +#define INFO_PACK_STATUS 0x22a8 > +#define RATE_GOVERNOR_STATUS 0x22ac > +#define DP_HORIZONTAL 0x22b0 > +#define DP_VERTICAL_0 0x22b4 > +#define DP_VERTICAL_1 0x22b8 > +#define DP_BLOCK_SDP 0x22bc > + > +/* dptx glbl addr */ > +#define DPTX_LANE_EN 0x2300 > +#define DPTX_ENHNCD 0x2304 > +#define DPTX_INT_MASK 0x2308 > +#define DPTX_INT_STATUS 0x230c > + > +/* dp aux addr */ > +#define DP_AUX_HOST_CONTROL 0x2800 > +#define DP_AUX_INTERRUPT_SOURCE 0x2804 > +#define DP_AUX_INTERRUPT_MASK 0x2808 > +#define DP_AUX_SWAP_INVERSION_CONTROL 0x280c > +#define DP_AUX_SEND_NACK_TRANSACTION 0x2810 > +#define DP_AUX_CLEAR_RX 0x2814 > +#define DP_AUX_CLEAR_TX 0x2818 > +#define DP_AUX_TIMER_STOP 0x281c > +#define DP_AUX_TIMER_CLEAR 0x2820 > +#define DP_AUX_RESET_SW 0x2824 > +#define DP_AUX_DIVIDE_2M 0x2828 > +#define DP_AUX_TX_PREACHARGE_LENGTH 0x282c > +#define DP_AUX_FREQUENCY_1M_MAX 0x2830 > +#define DP_AUX_FREQUENCY_1M_MIN 0x2834 > +#define DP_AUX_RX_PRE_MIN 0x2838 > +#define DP_AUX_RX_PRE_MAX 0x283c > +#define DP_AUX_TIMER_PRESET 0x2840 > +#define DP_AUX_NACK_FORMAT 0x2844 > +#define DP_AUX_TX_DATA 0x2848 > +#define DP_AUX_RX_DATA 0x284c > +#define DP_AUX_TX_STATUS 0x2850 > +#define DP_AUX_RX_STATUS 0x2854 > +#define DP_AUX_RX_CYCLE_COUNTER 0x2858 > +#define DP_AUX_MAIN_STATES 0x285c > +#define DP_AUX_MAIN_TIMER 0x2860 > +#define DP_AUX_AFE_OUT 0x2864 > + > +/* crypto addr */ > +#define CRYPTO_HDCP_REVISION 0x5800 > +#define HDCP_CRYPTO_CONFIG 0x5804 > +#define CRYPTO_INTERRUPT_SOURCE 0x5808 > +#define CRYPTO_INTERRUPT_MASK 0x580c > +#define CRYPTO22_CONFIG 0x5818 > +#define CRYPTO22_STATUS 0x581c > +#define SHA_256_DATA_IN 0x583c > +#define SHA_256_DATA_OUT_(x) (0x5850 + ((x) << 2)) > +#define AES_32_KEY_(x) (0x5870 + ((x) << 2)) > +#define AES_32_DATA_IN 0x5880 > +#define AES_32_DATA_OUT_(x) (0x5884 + ((x) << 2)) > +#define CRYPTO14_CONFIG 0x58a0 > +#define CRYPTO14_STATUS 0x58a4 > +#define CRYPTO14_PRNM_OUT 0x58a8 > +#define CRYPTO14_KM_0 0x58ac > +#define CRYPTO14_KM_1 0x58b0 > +#define CRYPTO14_AN_0 0x58b4 > +#define CRYPTO14_AN_1 0x58b8 > +#define CRYPTO14_YOUR_KSV_0 0x58bc > +#define CRYPTO14_YOUR_KSV_1 0x58c0 > +#define CRYPTO14_MI_0 0x58c4 > +#define CRYPTO14_MI_1 0x58c8 > +#define CRYPTO14_TI_0 0x58cc > +#define CRYPTO14_KI_0 0x58d0 > +#define CRYPTO14_KI_1 0x58d4 > +#define CRYPTO14_BLOCKS_NUM 0x58d8 > +#define CRYPTO14_KEY_MEM_DATA_0 0x58dc > +#define CRYPTO14_KEY_MEM_DATA_1 0x58e0 > +#define CRYPTO14_SHA1_MSG_DATA 0x58e4 > +#define CRYPTO14_SHA1_V_VALUE_(x) (0x58e8 + ((x) << 2)) > +#define TRNG_CTRL 0x58fc > +#define TRNG_DATA_RDY 0x5900 > +#define TRNG_DATA 0x5904 > + > +/* cipher addr */ > +#define HDCP_REVISION 0x60000 > +#define INTERRUPT_SOURCE 0x60004 > +#define INTERRUPT_MASK 0x60008 > +#define HDCP_CIPHER_CONFIG 0x6000c > +#define AES_128_KEY_0 0x60010 > +#define AES_128_KEY_1 0x60014 > +#define AES_128_KEY_2 0x60018 > +#define AES_128_KEY_3 0x6001c > +#define AES_128_RANDOM_0 0x60020 > +#define AES_128_RANDOM_1 0x60024 > +#define CIPHER14_KM_0 0x60028 > +#define CIPHER14_KM_1 0x6002c > +#define CIPHER14_STATUS 0x60030 > +#define CIPHER14_RI_PJ_STATUS 0x60034 > +#define CIPHER_MODE 0x60038 > +#define CIPHER14_AN_0 0x6003c > +#define CIPHER14_AN_1 0x60040 > +#define CIPHER22_AUTH 0x60044 > +#define CIPHER14_R0_DP_STATUS 0x60048 > +#define CIPHER14_BOOTSTRAP 0x6004c > + > +#define DPTX_FRMR_DATA_CLK_RSTN_EN BIT(11) > +#define DPTX_FRMR_DATA_CLK_EN BIT(10) > +#define DPTX_PHY_DATA_RSTN_EN BIT(9) > +#define DPTX_PHY_DATA_CLK_EN BIT(8) > +#define DPTX_PHY_CHAR_RSTN_EN BIT(7) > +#define DPTX_PHY_CHAR_CLK_EN BIT(6) > +#define SOURCE_AUX_SYS_CLK_RSTN_EN BIT(5) > +#define SOURCE_AUX_SYS_CLK_EN BIT(4) > +#define DPTX_SYS_CLK_RSTN_EN BIT(3) > +#define DPTX_SYS_CLK_EN BIT(2) > +#define CFG_DPTX_VIF_CLK_RSTN_EN BIT(1) > +#define CFG_DPTX_VIF_CLK_EN BIT(0) > + > +#define SOURCE_PHY_RSTN_EN BIT(1) > +#define SOURCE_PHY_CLK_EN BIT(0) > + > +#define SOURCE_PKT_SYS_RSTN_EN BIT(3) > +#define SOURCE_PKT_SYS_CLK_EN BIT(2) > +#define SOURCE_PKT_DATA_RSTN_EN BIT(1) > +#define SOURCE_PKT_DATA_CLK_EN BIT(0) > + > +#define SPDIF_CDR_CLK_RSTN_EN BIT(5) > +#define SPDIF_CDR_CLK_EN BIT(4) > +#define SOURCE_AIF_SYS_RSTN_EN BIT(3) > +#define SOURCE_AIF_SYS_CLK_EN BIT(2) > +#define SOURCE_AIF_CLK_RSTN_EN BIT(1) > +#define SOURCE_AIF_CLK_EN BIT(0) > + > +#define SOURCE_CIPHER_SYSTEM_CLK_RSTN_EN BIT(3) > +#define SOURCE_CIPHER_SYS_CLK_EN BIT(2) > +#define SOURCE_CIPHER_CHAR_CLK_RSTN_EN BIT(1) > +#define SOURCE_CIPHER_CHAR_CLK_EN BIT(0) > + > +#define SOURCE_CRYPTO_SYS_CLK_RSTN_EN BIT(1) > +#define SOURCE_CRYPTO_SYS_CLK_EN BIT(0) > + > +#define APB_IRAM_PATH BIT(2) > +#define APB_DRAM_PATH BIT(1) > +#define APB_XT_RESET BIT(0) > + > +#define MAILBOX_INT_MASK_BIT BIT(1) > +#define PIF_INT_MASK_BIT BIT(0) > +#define ALL_INT_MASK 3 > + > +/* mailbox */ > +#define MB_OPCODE_ID 0 > +#define MB_MODULE_ID 1 > +#define MB_SIZE_MSB_ID 2 > +#define MB_SIZE_LSB_ID 3 > +#define MB_DATA_ID 4 > + > +#define MB_MODULE_ID_DP_TX 0x01 > +#define MB_MODULE_ID_HDCP_TX 0x07 > +#define MB_MODULE_ID_HDCP_RX 0x08 > +#define MB_MODULE_ID_HDCP_GENERAL 0x09 > +#define MB_MODULE_ID_GENERAL 0x0a > + > +/* general opcode */ > +#define GENERAL_MAIN_CONTROL 0x01 > +#define GENERAL_TEST_ECHO 0x02 > +#define GENERAL_BUS_SETTINGS 0x03 > +#define GENERAL_TEST_ACCESS 0x04 > + > +#define DPTX_SET_POWER_MNG 0x00 > +#define DPTX_SET_HOST_CAPABILITIES 0x01 > +#define DPTX_GET_EDID 0x02 > +#define DPTX_READ_DPCD 0x03 > +#define DPTX_WRITE_DPCD 0x04 > +#define DPTX_ENABLE_EVENT 0x05 > +#define DPTX_WRITE_REGISTER 0x06 > +#define DPTX_READ_REGISTER 0x07 > +#define DPTX_WRITE_FIELD 0x08 > +#define DPTX_TRAINING_CONTROL 0x09 > +#define DPTX_READ_EVENT 0x0a > +#define DPTX_READ_LINK_STAT 0x0b > +#define DPTX_SET_VIDEO 0x0c > +#define DPTX_SET_AUDIO 0x0d > +#define DPTX_GET_LAST_AUX_STAUS 0x0e > +#define DPTX_SET_LINK_BREAK_POINT 0x0f > +#define DPTX_FORCE_LANES 0x10 > +#define DPTX_HPD_STATE 0x11 > + > +#define FW_STANDBY 0 > +#define FW_ACTIVE 1 > + > +#define DPTX_EVENT_ENABLE_HPD BIT(0) > +#define DPTX_EVENT_ENABLE_TRAINING BIT(1) > + > +#define LINK_TRAINING_NOT_ACTIVE 0 > +#define LINK_TRAINING_RUN 1 > +#define LINK_TRAINING_RESTART 2 > + > +#define CONTROL_VIDEO_IDLE 0 > +#define CONTROL_VIDEO_VALID 1 > + > +#define VIF_BYPASS_INTERLACE BIT(13) > +#define INTERLACE_FMT_DET BIT(12) > +#define INTERLACE_DTCT_WIN 0x20 > + > +#define DP_FRAMER_SP_INTERLACE_EN BIT(2) > +#define DP_FRAMER_SP_HSP BIT(1) > +#define DP_FRAMER_SP_VSP BIT(0) > + > +/* capability */ > +#define AUX_HOST_INVERT 3 > +#define FAST_LT_SUPPORT 1 > +#define FAST_LT_NOT_SUPPORT 0 > +#define LANE_MAPPING_NORMAL 0x1b > +#define LANE_MAPPING_FLIPPED 0xe4 > +#define ENHANCED 1 > + > +#define FULL_LT_STARTED BIT(0) > +#define FASE_LT_STARTED BIT(1) > +#define CLK_RECOVERY_FINISHED BIT(2) > +#define EQ_PHASE_FINISHED BIT(3) > +#define FASE_LT_START_FINISHED BIT(4) > +#define CLK_RECOVERY_FAILED BIT(5) > +#define EQ_PHASE_FAILED BIT(6) > +#define FASE_LT_FAILED BIT(7) > + > +#define DPTX_HPD_EVENT BIT(0) > +#define DPTX_TRAINING_EVENT BIT(1) > +#define HDCP_TX_STATUS_EVENT BIT(4) > +#define HDCP2_TX_IS_KM_STORED_EVENT BIT(5) > +#define HDCP2_TX_STORE_KM_EVENT BIT(6) > +#define HDCP_TX_IS_RECEIVER_ID_VALID_EVENT BIT(7) > + > +#define TU_SIZE 30 > +#define CDN_DP_MAX_LINK_RATE DP_LINK_BW_5_4 > + > +/* audio */ > +#define AUDIO_PACK_EN BIT(8) > +#define SAMPLING_FREQ(x) (((x) & 0xf) << 16) > +#define ORIGINAL_SAMP_FREQ(x) (((x) & 0xf) << 24) > +#define SYNC_WR_TO_CH_ZERO BIT(1) > +#define I2S_DEC_START BIT(1) > +#define AUDIO_SW_RST BIT(0) > +#define SMPL2PKT_EN BIT(1) > +#define MAX_NUM_CH(x) (((x) & 0x1f) - 1) > +#define NUM_OF_I2S_PORTS(x) ((((x) / 2 - 1) & 0x3) << 5) > +#define AUDIO_TYPE_LPCM (2 << 7) > +#define CFG_SUB_PCKT_NUM(x) ((((x) - 1) & 0x7) << 11) > +#define AUDIO_CH_NUM(x) ((((x) - 1) & 0x1f) << 2) > +#define TRANS_SMPL_WIDTH_16 0 > +#define TRANS_SMPL_WIDTH_24 BIT(11) > +#define TRANS_SMPL_WIDTH_32 (2 << 11) > +#define I2S_DEC_PORT_EN(x) (((x) & 0xf) << 17) > +#define SPDIF_ENABLE BIT(21) > +#define SPDIF_AVG_SEL BIT(20) > +#define SPDIF_JITTER_BYPASS BIT(19) > +#define SPDIF_FIFO_MID_RANGE(x) (((x) & 0xff) << 11) > +#define SPDIF_JITTER_THRSH(x) (((x) & 0xff) << 3) > +#define SPDIF_JITTER_AVG_WIN(x) ((x) & 0x7) > + > +/* Refernce cycles when using lane clock as refernce */ > +#define LANE_REF_CYC 0x8000 > + > +enum voltage_swing_level { > + VOLTAGE_LEVEL_0, > + VOLTAGE_LEVEL_1, > + VOLTAGE_LEVEL_2, > + VOLTAGE_LEVEL_3, > +}; > + > +enum pre_emphasis_level { > + PRE_EMPHASIS_LEVEL_0, > + PRE_EMPHASIS_LEVEL_1, > + PRE_EMPHASIS_LEVEL_2, > + PRE_EMPHASIS_LEVEL_3, > +}; > + > +enum pattern_set { > + PTS1 = BIT(0), > + PTS2 = BIT(1), > + PTS3 = BIT(2), > + PTS4 = BIT(3), > + DP_NONE = BIT(4) > +}; > + > +enum vic_color_depth { > + BCS_6 = 0x1, > + BCS_8 = 0x2, > + BCS_10 = 0x4, > + BCS_12 = 0x8, > + BCS_16 = 0x10, > +}; > + > +enum vic_bt_type { > + BT_601 = 0x0, > + BT_709 = 0x1, > +}; > + > +void cdn_dp_clock_reset(struct cdn_dp_device *dp); > + > +void cdn_dp_set_fw_clk(struct cdn_dp_device *dp, u32 clk); > +int cdn_dp_load_firmware(struct cdn_dp_device *dp, const u32 *i_mem, > + u32 i_size, const u32 *d_mem, u32 d_size); > +int cdn_dp_set_firmware_active(struct cdn_dp_device *dp, bool enable); > +int cdn_dp_set_host_cap(struct cdn_dp_device *dp, u8 lanes, bool flip); > +int cdn_dp_event_config(struct cdn_dp_device *dp); > +u32 cdn_dp_get_event(struct cdn_dp_device *dp); > +int cdn_dp_get_hpd_status(struct cdn_dp_device *dp); > +int cdn_dp_dpcd_write(struct cdn_dp_device *dp, u32 addr, u8 value); > +int cdn_dp_dpcd_read(struct cdn_dp_device *dp, u32 addr, u8 *data, u16 len); > +int cdn_dp_get_edid_block(void *dp, u8 *edid, > + unsigned int block, size_t length); > +int cdn_dp_training_start(struct cdn_dp_device *dp); > +int cdn_dp_get_training_status(struct cdn_dp_device *dp); > +int cdn_dp_set_video_status(struct cdn_dp_device *dp, int active); > +int cdn_dp_config_video(struct cdn_dp_device *dp); > +int cdn_dp_audio_stop(struct cdn_dp_device *dp, struct audio_info *audio); > +int cdn_dp_audio_mute(struct cdn_dp_device *dp, bool enable); > +int cdn_dp_audio_config(struct cdn_dp_device *dp, struct audio_info *audio); > +#endif /* _CDN_DP_REG_H */ > diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c > index edd7ec2..d723d8e 100644 > --- a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c > +++ b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c > @@ -969,9 +969,11 @@ static void vop_crtc_enable(struct drm_crtc *crtc) > vop_dsp_hold_valid_irq_disable(vop); > } > > - pin_pol = 0x8; > - pin_pol |= (adjusted_mode->flags & DRM_MODE_FLAG_NHSYNC) ? 0 : 1; > - pin_pol |= (adjusted_mode->flags & DRM_MODE_FLAG_NVSYNC) ? 0 : (1 << 1); > + pin_pol = BIT(DCLK_INVERT); > + pin_pol |= (adjusted_mode->flags & DRM_MODE_FLAG_NHSYNC) ? > + 0 : BIT(HSYNC_POSITIVE); > + pin_pol |= (adjusted_mode->flags & DRM_MODE_FLAG_NVSYNC) ? > + 0 : BIT(VSYNC_POSITIVE); > VOP_CTRL_SET(vop, pin_pol, pin_pol); > > switch (s->output_type) { > @@ -991,6 +993,11 @@ static void vop_crtc_enable(struct drm_crtc *crtc) > VOP_CTRL_SET(vop, mipi_pin_pol, pin_pol); > VOP_CTRL_SET(vop, mipi_en, 1); > break; > + case DRM_MODE_CONNECTOR_DisplayPort: > + pin_pol &= ~BIT(DCLK_INVERT); > + VOP_CTRL_SET(vop, dp_pin_pol, pin_pol); > + VOP_CTRL_SET(vop, dp_en, 1); > + break; > default: > DRM_ERROR("unsupport connector_type[%d]\n", s->output_type); > } > diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_vop.h b/drivers/gpu/drm/rockchip/rockchip_drm_vop.h > index ff4f52e..4820a8b 100644 > --- a/drivers/gpu/drm/rockchip/rockchip_drm_vop.h > +++ b/drivers/gpu/drm/rockchip/rockchip_drm_vop.h > @@ -45,6 +45,7 @@ struct vop_ctrl { > struct vop_reg edp_en; > struct vop_reg hdmi_en; > struct vop_reg mipi_en; > + struct vop_reg dp_en; > struct vop_reg out_mode; > struct vop_reg dither_down; > struct vop_reg dither_up; > @@ -53,6 +54,7 @@ struct vop_ctrl { > struct vop_reg hdmi_pin_pol; > struct vop_reg edp_pin_pol; > struct vop_reg mipi_pin_pol; > + struct vop_reg dp_pin_pol; > > struct vop_reg htotal_pw; > struct vop_reg hact_st_end; > @@ -242,6 +244,13 @@ enum scale_down_mode { > SCALE_DOWN_AVG = 0x1 > }; > > +enum vop_pol { > + HSYNC_POSITIVE = 0, > + VSYNC_POSITIVE = 1, > + DEN_NEGATIVE = 2, > + DCLK_INVERT = 3 > +}; > + > #define FRAC_16_16(mult, div) (((mult) << 16) / (div)) > #define SCL_FT_DEFAULT_FIXPOINT_SHIFT 12 > #define SCL_MAX_VSKIPLINES 4 > diff --git a/drivers/gpu/drm/rockchip/rockchip_vop_reg.c b/drivers/gpu/drm/rockchip/rockchip_vop_reg.c > index 5b1ae1f..dcf172e 100644 > --- a/drivers/gpu/drm/rockchip/rockchip_vop_reg.c > +++ b/drivers/gpu/drm/rockchip/rockchip_vop_reg.c > @@ -281,6 +281,7 @@ static const struct vop_data rk3288_vop = { > static const struct vop_ctrl rk3399_ctrl_data = { > .standby = VOP_REG(RK3399_SYS_CTRL, 0x1, 22), > .gate_en = VOP_REG(RK3399_SYS_CTRL, 0x1, 23), > + .dp_en = VOP_REG(RK3399_SYS_CTRL, 0x1, 11), > .rgb_en = VOP_REG(RK3399_SYS_CTRL, 0x1, 12), > .hdmi_en = VOP_REG(RK3399_SYS_CTRL, 0x1, 13), > .edp_en = VOP_REG(RK3399_SYS_CTRL, 0x1, 14), > @@ -290,6 +291,7 @@ static const struct vop_ctrl rk3399_ctrl_data = { > .data_blank = VOP_REG(RK3399_DSP_CTRL0, 0x1, 19), > .out_mode = VOP_REG(RK3399_DSP_CTRL0, 0xf, 0), > .rgb_pin_pol = VOP_REG(RK3399_DSP_CTRL1, 0xf, 16), > + .dp_pin_pol = VOP_REG(RK3399_DSP_CTRL1, 0xf, 16), > .hdmi_pin_pol = VOP_REG(RK3399_DSP_CTRL1, 0xf, 20), > .edp_pin_pol = VOP_REG(RK3399_DSP_CTRL1, 0xf, 24), > .mipi_pin_pol = VOP_REG(RK3399_DSP_CTRL1, 0xf, 28), -- Ｍark Yao 姚智情 Rockchip 福州瑞芯微电子有限公司 Fuzhou Headquarters Addr:No.21 Building, A District, Fuzhou Software Park, 89 Soft Avenue, Tongpan Road, Gulou District, Fuzhou (350003) 地址:福建省福州市铜盘路软件大道89号软件园A区21号楼 (350003) Tel:（86-0591）83991906 - 8296 E-mail:mark.yao@rock-chips.com From mboxrd@z Thu Jan 1 00:00:00 1970 From: Mark yao Subject: Re: [v10.1 PATCH 5/5] drm/rockchip: cdn-dp: add cdn DP support for rk3399 Date: Fri, 12 Aug 2016 10:06:40 +0800 Message-ID: <57AD2F30.9050408@rock-chips.com> References: <1470785557-21974-6-git-send-email-zyw@rock-chips.com> <1470871932-17419-1-git-send-email-zyw@rock-chips.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1470871932-17419-1-git-send-email-zyw@rock-chips.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Chris Zhong , dianders@chromium.org, tfiga@chromium.org, heiko@sntech.de, yzq@rock-chips.com, groeck@chromium.org, myungjoo.ham@samsung.com, cw00.choi@samsung.com, wulf@rock-chips.com, marcheu@chromium.org Cc: linux-rockchip@lists.infradead.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-arm-kernel@lists.infradead.org List-Id: linux-rockchip.vger.kernel.org SGkgQ2hyaXMKCkxvb2tzIGdvb2QgZm9yIG1lCgpvbmx5IHRpbnkgcHJvYmxlbSBjb21tZW50IGlu bGluZS4KClRoYW5rcy4KCk9uIDIwMTblubQwOOaciDEx5pelIDA3OjMyLCBDaHJpcyBaaG9uZyB3 cm90ZToKPiBBZGQgc3VwcG9ydCBmb3IgY2RuIERQIGNvbnRyb2xsZXIgd2hpY2ggaXMgZW1iZWRk ZWQgaW4gdGhlIHJrMzM5OQo+IFNvQ3MuIFRoZSBEUCBpcyBjb21wbGlhbnQgd2l0aCBEaXNwbGF5 UG9ydCBTcGVjaWZpY2F0aW9uLAo+IFZlcnNpb24gMS4zLCBUaGlzIElQIGlzIGNvbXBhdGlibGUg d2l0aCB0aGUgcm9ja2NoaXAgdHlwZS1jIFBIWSBJUC4KPiBUaGVyZSBpcyBhIHVDUFUgaW4gRFAg Y29udHJvbGxlciwgaXQgbmVlZCBhIGZpcm13YXJlIHRvIHdvcmssCj4gcGxlYXNlIHB1dCB0aGUg ZmlybXdhcmUgZmlsZSB0byAvbGliL2Zpcm13YXJlL3JvY2tjaGlwL2RwdHguYmluLiBUaGUKPiB1 Q1BVIGluIGNoYXJnZSBvZiBhdXggY29tbXVuaWNhdGlvbiBhbmQgbGluayB0cmFpbmluZywgdGhl IGhvc3QgdXNlCj4gbWFpbGJveCB0byBjb21tdW5pY2F0ZSB3aXRoIHRoZSB1Y3B1Lgo+IFRoZSBk Y2xrIHBpbl9wb2wgb2Ygdm9wIG11c3Qgbm90IGJlIGludmVydCBmb3IgRFAuCj4KPiBTaWduZWQt b2ZmLWJ5OiBDaHJpcyBaaG9uZyA8enl3QHJvY2stY2hpcHMuY29tPgo+IFJldmlld2VkLWJ5OiBT ZWFuIFBhdWwgPHNlYW5wYXVsQGNocm9taXVtLm9yZz4KPiBBY2tlZC1ieTogTWFyayBZYW8gPG1h cmsueWFvQHJvY2stY2hpcHMuY29tPgo+Cj4gLS0tCj4KPiBDaGFuZ2VzIGluIHYxMC4xOgo+IC0g c3VwcG9ydCByZWFkIHNpbmsgY291bnQgZnJvbSBEUENECj4KPiBDaGFuZ2VzIGluIHYxMDoKPiAt IGNvbnRyb2wgdGhlIGdyZl9jbGsgaW4gRFAKPgo+IENoYW5nZXMgaW4gdjk6Cj4gLSBkbyBub3Qg bmVlZCByZXNldCB0aGUgcGh5IGJlZm9yZSBwb3dlcl9vbgo+IC0gYWRkIGEgb3JpZW50YXRpb24g aW5mb3JtYXRpb24gZm9yIHNldF9jYXBhYmlsaXR5Cj4gLSByZXRyeSB0byByZWFkIGRwY2QgaW4g MTAgc2Vjb25kcwo+Cj4gQ2hhbmdlcyBpbiB2ODoKPiAtIG9wdGltaXphdGlvbiB0aGUgZXJyIGxv Zwo+Cj4gQ2hhbmdlcyBpbiB2NzoKPiAtIHN1cHBvcnQgZmlybXdhcmUgc3RhbmRieSB3aGVuIG5v IGRwdHggY29ubmVjdGlvbgo+IC0gb3B0aW1pemF0aW9uIHRoZSBjYWxjdWxhdGlvbiBvZiB0dSBz aXplIGFuZCB2YWxpZCBzeW1ib2wKPgo+IENoYW5nZXMgaW4gdjY6Cj4gLSBhZGQgYSBwb3J0IHN0 cnVjdAo+IC0gc2VsZWN0IFNORF9TT0NfSERNSV9DT0RFQwo+IC0gZm9yY2UgcmVzZXQgdGhlIHBo eSB3aGVuIGhwZCBkZXRlY3RlZAo+Cj4gQ2hhbmdlcyBpbiB2NToKPiAtIGFscGhhYmV0aWNhbCBv cmRlcgo+IC0gZG8gbm90IHVzZSBsb25nLCB1c2UgdTMyIG9yIHU2NAo+IC0gcmV0dXJuIE1PREVf Q0xPQ0tfSElHSCB3aGVuIHJlcXVlc3RlZCA+IGFjdHVhbAo+IC0gT3B0aW1pemVkIENvZGluZyBT dHlsZQo+IC0gYWRkIGEgZm9ybXVsYSB0byBnZXQgYmV0dGVyIHR1IHNpemUgYW5kIHN5bWJvbCB2 YWx1ZS4KPiAtIG1vZGlmeSBhY2NvcmRpbmcgdG8gU2VhbiBQYXVsJ3MgY29tbWVudHMKPiAtIGZp eGVkIHRoZSBmd193YWl0IGFsd2F5cyAwCj4KPiBDaGFuZ2VzIGluIHY0Ogo+IC0gdXNlIHBoeSBm cmFtZXdvcmsgdG8gY29udHJvbCBEUCBwaHkKPiAtIHN1cHBvcnQgMiBwaHlzCj4KPiBDaGFuZ2Vz IGluIHYzOgo+IC0gdXNlIEVYVENPTl9ESVNQX0RQIGFuZCBFWFRDT05fRElTUF9EUF9BTFQgY2Fi bGUgdG8gZ2V0IGRwIHBvcnQgc3RhdGUuCj4gLSByZXNldCBzcGRpZiBiZWZvcmUgY29uZmlnIGl0 Cj4gLSBtb2RpZnkgdGhlIGZpcm13YXJlIGNsayB0byAxMDBNaHoKPiAtIHJldHJ5IGxvYWQgZmly bXdhcmUgaWYgZncgZmlsZSBpcyByZXF1ZXN0ZWQgdG9vIGVhcmx5Cj4KPiBDaGFuZ2VzIGluIHYy Ogo+IC0gQWxwaGFiZXRpYyBvcmRlcgo+IC0gcmVtb3ZlIGV4Y2VzcyBlcnJvciBtZXNzYWdlCj4g LSB1c2UgZGVmaW5lIGNsa19yYXRlCj4gLSBjaGVjayBhbGwgcmV0dXJuIHZhbHVlCj4gLSByZW1v dmUgZGV2X3NldF9uYW1lKGRwLT5kZXYsICJjZG4tZHAiKTsKPiAtIHVzZSBzY2hlZHVsZV9kZWxh eWVkX3dvcmsKPiAtIHJlbW92ZSBuZXZlci1jYWxsZWQgZnVuY3Rpb25zCj4gLSByZW1vdmUgc29t ZSB1bm5lY2Vzc2FyeSAoKQo+Cj4gQ2hhbmdlcyBpbiB2MToKPiAtIHVzZSBleHRjb24gQVBJCj4g LSB1c2UgaGRtaS1jb2RlYyBmb3IgdGhlIERQIEFzb2MKPiAtIGRvIG5vdCBpbml0aWFsaXplIHRo ZSAicmV0Igo+IC0gcHJpbnRrIGEgZXJyIGxvZyB3aGVuIGRybV9vZl9lbmNvZGVyX2FjdGl2ZV9l bmRwb2ludF9pZAo+IC0gbW9kaWZ5IHRoZSBkY2xrIHBpbl9wb2wgdG8gYSBzaW5nbGUgbGluZQo+ Cj4gICBkcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvS2NvbmZpZyAgICAgICAgICAgIHwgIDEwICsK PiAgIGRyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9NYWtlZmlsZSAgICAgICAgICAgfCAgIDEgKwo+ ICAgZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL2Nkbi1kcC1jb3JlLmMgICAgICB8IDkzNyArKysr KysrKysrKysrKysrKysrKysrKysrKysKPiAgIGRyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9jZG4t ZHAtY29yZS5oICAgICAgfCAxMDQgKysrCj4gICBkcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvY2Ru LWRwLXJlZy5jICAgICAgIHwgOTU5ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysKPiAgIGRy aXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9jZG4tZHAtcmVnLmggICAgICAgfCA0ODIgKysrKysrKysr KysrKysKPiAgIGRyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9yb2NrY2hpcF9kcm1fdm9wLmMgfCAg MTMgKy0KPiAgIGRyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9yb2NrY2hpcF9kcm1fdm9wLmggfCAg IDkgKwo+ICAgZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL3JvY2tjaGlwX3ZvcF9yZWcuYyB8ICAg MiArCj4gICA5IGZpbGVzIGNoYW5nZWQsIDI1MTQgaW5zZXJ0aW9ucygrKSwgMyBkZWxldGlvbnMo LSkKPiAgIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvY2RuLWRw LWNvcmUuYwo+ICAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9j ZG4tZHAtY29yZS5oCj4gICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL3JvY2tj aGlwL2Nkbi1kcC1yZWcuYwo+ICAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS9y b2NrY2hpcC9jZG4tZHAtcmVnLmgKPgo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcm9j a2NoaXAvS2NvbmZpZyBiL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9LY29uZmlnCj4gaW5kZXgg ZDMwYmRjMy4uMjBhYWFmZSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAv S2NvbmZpZwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9LY29uZmlnCj4gQEAgLTI1 LDYgKzI1LDE2IEBAIGNvbmZpZyBST0NLQ0hJUF9BTkFMT0dJWF9EUAo+ICAgCSAgZm9yIHRoZSBB bmFsb2dpeCBDb3JlIERQIGRyaXZlci4gSWYgeW91IHdhbnQgdG8gZW5hYmxlIERQCj4gICAJICBv biBSSzMyODggYmFzZWQgU29DLCB5b3Ugc2hvdWxkIHNlbGV0IHRoaXMgb3B0aW9uLgo+ICAgCj4g K2NvbmZpZyBST0NLQ0hJUF9DRE5fRFAKPiArICAgICAgICB0cmlzdGF0ZSAiUm9ja2NoaXAgY2Ru IERQIgo+ICsgICAgICAgIGRlcGVuZHMgb24gRFJNX1JPQ0tDSElQCj4gKwlzZWxlY3QgU05EX1NP Q19IRE1JX0NPREVDIGlmIFNORF9TT0MKPiArICAgICAgICBoZWxwCj4gKwkgIFRoaXMgc2VsZWN0 cyBzdXBwb3J0IGZvciBSb2NrY2hpcCBTb0Mgc3BlY2lmaWMgZXh0ZW5zaW9ucwo+ICsJICBmb3Ig dGhlIGNkbiBEUCBkcml2ZXIuIElmIHlvdSB3YW50IHRvIGVuYWJsZSBEcCBvbgo+ICsJICBSSzMz OTkgYmFzZWQgU29DLCB5b3Ugc2hvdWxkIHNlbGVjdCB0aGlzCj4gKwkgIG9wdGlvbi4KPiArCj4g ICBjb25maWcgUk9DS0NISVBfRFdfSERNSQo+ICAgICAgICAgICB0cmlzdGF0ZSAiUm9ja2NoaXAg c3BlY2lmaWMgZXh0ZW5zaW9ucyBmb3IgU3lub3BzeXMgRFcgSERNSSIKPiAgICAgICAgICAgZGVw ZW5kcyBvbiBEUk1fUk9DS0NISVAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JvY2tj aGlwL01ha2VmaWxlIGIvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL01ha2VmaWxlCj4gaW5kZXgg MDVkMDcxMy4uYWJkZWNkNSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAv TWFrZWZpbGUKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvTWFrZWZpbGUKPiBAQCAt Nyw2ICs3LDcgQEAgcm9ja2NoaXBkcm0teSA6PSByb2NrY2hpcF9kcm1fZHJ2Lm8gcm9ja2NoaXBf ZHJtX2ZiLm8gXAo+ICAgcm9ja2NoaXBkcm0tJChDT05GSUdfRFJNX0ZCREVWX0VNVUxBVElPTikg Kz0gcm9ja2NoaXBfZHJtX2ZiZGV2Lm8KPiAgIAo+ICAgb2JqLSQoQ09ORklHX1JPQ0tDSElQX0FO QUxPR0lYX0RQKSArPSBhbmFsb2dpeF9kcC1yb2NrY2hpcC5vCj4gK29iai0kKENPTkZJR19ST0NL Q0hJUF9DRE5fRFApICs9IGNkbi1kcC1jb3JlLm8gY2RuLWRwLXJlZy5vCj4gICBvYmotJChDT05G SUdfUk9DS0NISVBfRFdfSERNSSkgKz0gZHdfaGRtaS1yb2NrY2hpcC5vCj4gICBvYmotJChDT05G SUdfUk9DS0NISVBfRFdfTUlQSV9EU0kpICs9IGR3LW1pcGktZHNpLm8KPiAgIG9iai0kKENPTkZJ R19ST0NLQ0hJUF9JTk5PX0hETUkpICs9IGlubm9faGRtaS5vCj4gZGlmZiAtLWdpdCBhL2RyaXZl cnMvZ3B1L2RybS9yb2NrY2hpcC9jZG4tZHAtY29yZS5jIGIvZHJpdmVycy9ncHUvZHJtL3JvY2tj aGlwL2Nkbi1kcC1jb3JlLmMKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAu LmY5YTVhZmIKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlw L2Nkbi1kcC1jb3JlLmMKPiBAQCAtMCwwICsxLDkzNyBAQAo+ICsvKgo+ICsgKiBDb3B5cmlnaHQg KEMpIEZ1emhvdSBSb2NrY2hpcCBFbGVjdHJvbmljcyBDby5MdGQKPiArICogQXV0aG9yOiBDaHJp cyBaaG9uZyA8enl3QHJvY2stY2hpcHMuY29tPgo+ICsgKgo+ICsgKiBUaGlzIHNvZnR3YXJlIGlz IGxpY2Vuc2VkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljCj4gKyAq IExpY2Vuc2UgdmVyc2lvbiAyLCBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91 bmRhdGlvbiwgYW5kCj4gKyAqIG1heSBiZSBjb3BpZWQsIGRpc3RyaWJ1dGVkLCBhbmQgbW9kaWZp ZWQgdW5kZXIgdGhvc2UgdGVybXMuCj4gKyAqCj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmli dXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAo+ICsgKiBidXQgV0lUSE9V VCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgo+ICsg KiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBT ZWUgdGhlCj4gKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMu Cj4gKyAqLwo+ICsKPiArI2luY2x1ZGUgPGRybS9kcm1QLmg+Cj4gKyNpbmNsdWRlIDxkcm0vZHJt X2F0b21pY19oZWxwZXIuaD4KPiArI2luY2x1ZGUgPGRybS9kcm1fY3J0Y19oZWxwZXIuaD4KPiAr I2luY2x1ZGUgPGRybS9kcm1fZHBfaGVscGVyLmg+Cj4gKyNpbmNsdWRlIDxkcm0vZHJtX2VkaWQu aD4KPiArI2luY2x1ZGUgPGRybS9kcm1fb2YuaD4KPiArCj4gKyNpbmNsdWRlIDxsaW51eC9jbGsu aD4KPiArI2luY2x1ZGUgPGxpbnV4L2NvbXBvbmVudC5oPgo+ICsjaW5jbHVkZSA8bGludXgvZXh0 Y29uLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9maXJtd2FyZS5oPgo+ICsjaW5jbHVkZSA8bGludXgv cmVnbWFwLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9yZXNldC5oPgo+ICsKPiArI2luY2x1ZGUgPGxp bnV4L21mZC9zeXNjb24uaD4KPiArI2luY2x1ZGUgPGxpbnV4L3BoeS9waHkuaD4KPiArCj4gKyNp bmNsdWRlIDxzb3VuZC9oZG1pLWNvZGVjLmg+Cj4gKwo+ICsjaW5jbHVkZSAiY2RuLWRwLWNvcmUu aCIKPiArI2luY2x1ZGUgImNkbi1kcC1yZWcuaCIKPiArI2luY2x1ZGUgInJvY2tjaGlwX2RybV92 b3AuaCIKPiArCj4gKyNkZWZpbmUgY29ubmVjdG9yX3RvX2RwKGMpIFwKPiArCQljb250YWluZXJf b2YoYywgc3RydWN0IGNkbl9kcF9kZXZpY2UsIGNvbm5lY3RvcikKPiArCj4gKyNkZWZpbmUgZW5j b2Rlcl90b19kcChjKSBcCj4gKwkJY29udGFpbmVyX29mKGMsIHN0cnVjdCBjZG5fZHBfZGV2aWNl LCBlbmNvZGVyKQo+ICsKPiArLyogZHAgZ3JmIHJlZ2lzdGVyIG9mZnNldCAqLwo+ICsjZGVmaW5l IEdSRl9TT0NfQ09OOQkJMHg2MjI0Cj4gKyNkZWZpbmUgRFBfU0VMX1ZPUF9MSVQJCUJJVCgxMikK PiArI2RlZmluZSBHUkZfU09DX0NPTjI2CQkweDYyNjgKPiArI2RlZmluZSBVUEhZX1NFTF9CSVQJ CTMKPiArI2RlZmluZSBVUEhZX1NFTF9NQVNLCQlCSVQoMTkpCj4gKyNkZWZpbmUgRFBUWF9IUERf U0VMCQkoMyA8PCAxMikKPiArI2RlZmluZSBEUFRYX0hQRF9ERUwJCSgyIDw8IDEyKQo+ICsjZGVm aW5lIERQVFhfSFBEX1NFTF9NQVNLCSgzIDw8IDI4KQo+ICsKPiArI2RlZmluZSBNQVhfRldfV0FJ VF9TRUNTCTY0Cj4gKyNkZWZpbmUgQ0ROX0RQX0ZJUk1XQVJFCQkicm9ja2NoaXAvZHB0eC5iaW4i Cj4gKwo+ICtzdHJ1Y3QgY2RuX2RwX2RhdGEgewo+ICsJdTggbWF4X3BoeTsKPiArfTsKPiArCj4g K3N0cnVjdCBjZG5fZHBfZGF0YSByazMzOTlfY2RuX2RwID0gewo+ICsJLm1heF9waHkgPSAyLAo+ ICt9Owo+ICsKPiArc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgY2RuX2RwX2R0X2lk c1tdID0gewo+ICsJeyAuY29tcGF0aWJsZSA9ICJyb2NrY2hpcCxyazMzOTktY2RuLWRwIiwKPiAr CQkuZGF0YSA9ICh2b2lkICopJnJrMzM5OV9jZG5fZHAgfSwKPiArCXt9Cj4gK307Cj4gKwo+ICtN T0RVTEVfREVWSUNFX1RBQkxFKG9mLCBjZG5fZHBfZHRfaWRzKTsKPiArCj4gK3N0YXRpYyBpbnQg Y2RuX2RwX2dyZl93cml0ZShzdHJ1Y3QgY2RuX2RwX2RldmljZSAqZHAsCj4gKwkJCSAgICB1bnNp Z25lZCBpbnQgcmVnLCB1bnNpZ25lZCBpbnQgdmFsKQo+ICt7Cj4gKwlpbnQgcmV0Owo+ICsKPiAr CXJldCA9IGNsa19wcmVwYXJlX2VuYWJsZShkcC0+Z3JmX2Nsayk7Cj4gKwlpZiAocmV0KSB7Cj4g KwkJZGV2X2VycihkcC0+ZGV2LCAiRmFpbGVkIHRvIHByZXBhcmVfZW5hYmxlIGdyZiBjbG9ja1xu Iik7Cj4gKwkJcmV0dXJuIHJldDsKPiArCX0KPiArCj4gKwlyZXQgPSByZWdtYXBfd3JpdGUoZHAt PmdyZiwgcmVnLCB2YWwpOwo+ICsJaWYgKHJldCkgewo+ICsJCWRldl9lcnIoZHAtPmRldiwgIkNv dWxkIG5vdCB3cml0ZSB0byBHUkY6ICVkXG4iLCByZXQpOwo+ICsJCXJldHVybiByZXQ7Cj4gKwl9 Cj4gKwo+ICsJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKGRwLT5ncmZfY2xrKTsKPiArCj4gKwlyZXR1 cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIGludCBjZG5fZHBfY2xrX2VuYWJsZShzdHJ1Y3QgY2Ru X2RwX2RldmljZSAqZHApCj4gK3sKPiArCWludCByZXQ7Cj4gKwl1MzIgcmF0ZTsKPiArCj4gKwly ZXQgPSBjbGtfcHJlcGFyZV9lbmFibGUoZHAtPnBjbGspOwo+ICsJaWYgKHJldCA8IDApIHsKPiAr CQlkZXZfZXJyKGRwLT5kZXYsICJjYW5ub3QgZW5hYmxlIGRwIHBjbGsgJWRcbiIsIHJldCk7Cj4g KwkJZ290byBlcnJfcGNsazsKPiArCX0KPiArCj4gKwlyZXQgPSBjbGtfcHJlcGFyZV9lbmFibGUo ZHAtPmNvcmVfY2xrKTsKPiArCWlmIChyZXQgPCAwKSB7Cj4gKwkJZGV2X2VycihkcC0+ZGV2LCAi Y2Fubm90IGVuYWJsZSBjb3JlX2NsayAlZFxuIiwgcmV0KTsKPiArCQlnb3RvIGVycl9jb3JlX2Ns azsKPiArCX0KPiArCj4gKwlyYXRlID0gY2xrX2dldF9yYXRlKGRwLT5jb3JlX2Nsayk7Cj4gKwlp ZiAocmF0ZSA8IDApIHsKPiArCQlkZXZfZXJyKGRwLT5kZXYsICJnZXQgY2xrIHJhdGUgZmFpbGVk OiAlZFxuIiwgcmF0ZSk7Cj4gKwkJZ290byBlcnJfc2V0X3JhdGU7Cj4gKwl9Cj4gKwo+ICsJY2Ru X2RwX3NldF9md19jbGsoZHAsIHJhdGUpOwo+ICsKPiArCXJldHVybiAwOwo+ICsKPiArZXJyX3Nl dF9yYXRlOgo+ICsJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKGRwLT5jb3JlX2Nsayk7Cj4gK2Vycl9j b3JlX2NsazoKPiArCWNsa19kaXNhYmxlX3VucHJlcGFyZShkcC0+cGNsayk7Cj4gK2Vycl9wY2xr Ogo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiArc3RhdGljIGVudW0gZHJtX2Nvbm5lY3Rvcl9z dGF0dXMKPiArY2RuX2RwX2Nvbm5lY3Rvcl9kZXRlY3Qoc3RydWN0IGRybV9jb25uZWN0b3IgKmNv bm5lY3RvciwgYm9vbCBmb3JjZSkKPiArewo+ICsJc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwID0g Y29ubmVjdG9yX3RvX2RwKGNvbm5lY3Rvcik7Cj4gKwo+ICsJcmV0dXJuIGRwLT5ocGRfc3RhdHVz Owo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCBjZG5fZHBfY29ubmVjdG9yX2Rlc3Ryb3koc3RydWN0 IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcikKPiArewo+ICsJZHJtX2Nvbm5lY3Rvcl91bnJlZ2lz dGVyKGNvbm5lY3Rvcik7Cj4gKwlkcm1fY29ubmVjdG9yX2NsZWFudXAoY29ubmVjdG9yKTsKPiAr fQo+ICsKPiArc3RhdGljIHN0cnVjdCBkcm1fY29ubmVjdG9yX2Z1bmNzIGNkbl9kcF9hdG9taWNf Y29ubmVjdG9yX2Z1bmNzID0gewo+ICsJLmRwbXMgPSBkcm1fYXRvbWljX2hlbHBlcl9jb25uZWN0 b3JfZHBtcywKPiArCS5kZXRlY3QgPSBjZG5fZHBfY29ubmVjdG9yX2RldGVjdCwKPiArCS5kZXN0 cm95ID0gY2RuX2RwX2Nvbm5lY3Rvcl9kZXN0cm95LAo+ICsJLmZpbGxfbW9kZXMgPSBkcm1faGVs cGVyX3Byb2JlX3NpbmdsZV9jb25uZWN0b3JfbW9kZXMsCj4gKwkucmVzZXQgPSBkcm1fYXRvbWlj X2hlbHBlcl9jb25uZWN0b3JfcmVzZXQsCj4gKwkuYXRvbWljX2R1cGxpY2F0ZV9zdGF0ZSA9IGRy bV9hdG9taWNfaGVscGVyX2Nvbm5lY3Rvcl9kdXBsaWNhdGVfc3RhdGUsCj4gKwkuYXRvbWljX2Rl c3Ryb3lfc3RhdGUgPSBkcm1fYXRvbWljX2hlbHBlcl9jb25uZWN0b3JfZGVzdHJveV9zdGF0ZSwK PiArfTsKPiArCj4gK3N0YXRpYyBpbnQgY2RuX2RwX2Nvbm5lY3Rvcl9nZXRfbW9kZXMoc3RydWN0 IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcikKPiArewo+ICsJc3RydWN0IGNkbl9kcF9kZXZpY2Ug KmRwID0gY29ubmVjdG9yX3RvX2RwKGNvbm5lY3Rvcik7Cj4gKwlzdHJ1Y3QgZWRpZCAqZWRpZDsK PiArCWludCByZXQgPSAwOwo+ICsKPiArCWVkaWQgPSBkcm1fZG9fZ2V0X2VkaWQoY29ubmVjdG9y LCBjZG5fZHBfZ2V0X2VkaWRfYmxvY2ssIGRwKTsKPiArCWlmIChlZGlkKSB7Cj4gKwkJZGV2X2Ri ZyhkcC0+ZGV2LCAiZ290IGVkaWQ6IHdpZHRoWyVkXSB4IGhlaWdodFslZF1cbiIsCj4gKwkJCWVk aWQtPndpZHRoX2NtLCBlZGlkLT5oZWlnaHRfY20pOwo+ICsKPiArCQlkcC0+c2lua19oYXNfYXVk aW8gPSBkcm1fZGV0ZWN0X21vbml0b3JfYXVkaW8oZWRpZCk7Cj4gKwkJcmV0ID0gZHJtX2FkZF9l ZGlkX21vZGVzKGNvbm5lY3RvciwgZWRpZCk7Cj4gKwkJaWYgKHJldCkgewo+ICsJCQlkcm1fbW9k ZV9jb25uZWN0b3JfdXBkYXRlX2VkaWRfcHJvcGVydHkoY29ubmVjdG9yLAo+ICsJCQkJCQkJCWVk aWQpOwo+ICsJCQlkcm1fZWRpZF90b19lbGQoY29ubmVjdG9yLCBlZGlkKTsKPiArCQl9Cj4gKwkJ a2ZyZWUoZWRpZCk7Cj4gKwl9Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiArc3RhdGlj IHN0cnVjdCBkcm1fZW5jb2RlciAqCj4gKwljZG5fZHBfY29ubmVjdG9yX2Jlc3RfZW5jb2Rlcihz dHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yKQo+ICt7Cj4gKwlzdHJ1Y3QgY2RuX2RwX2Rl dmljZSAqZHAgPSBjb25uZWN0b3JfdG9fZHAoY29ubmVjdG9yKTsKPiArCj4gKwlyZXR1cm4gJmRw LT5lbmNvZGVyOwo+ICt9CgpJIHRoaW5rIGNkbi1kcCBoYXZlIGEgMToxIHJlbGF0aW9uc2hpcCBi ZXR3ZWVuIGNvbm5lY3RvcnMgYW5kIGVuY29kZXJzLApTaW5jZSB0aGUgY29tbWl0KGM2MWI5M2Yg ZHJtL2F0b21pYzogRml4IHJlbWFpbmluZyBwbGFjZXMgd2hlcmUgCiFmdW5jcy0+YmVzdF9lbmNv ZGVyIGlzIHZhbGlkKSwKCnRoZSBiZXN0X2VuY29kZXIgb3BzIGNhbiBiZSByZW1vdmVkLgoKPiAr Cj4gK3N0YXRpYyBpbnQgY2RuX2RwX2Nvbm5lY3Rvcl9tb2RlX3ZhbGlkKHN0cnVjdCBkcm1fY29u bmVjdG9yICpjb25uZWN0b3IsCj4gKwkJCQkgICAgICAgc3RydWN0IGRybV9kaXNwbGF5X21vZGUg Km1vZGUpCj4gK3sKPiArCXN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCA9IGNvbm5lY3Rvcl90b19k cChjb25uZWN0b3IpOwo+ICsJc3RydWN0IGRybV9kaXNwbGF5X2luZm8gKmRpc3BsYXlfaW5mbyA9 ICZkcC0+Y29ubmVjdG9yLmRpc3BsYXlfaW5mbzsKPiArCXUzMiByZXF1ZXN0ZWQgPSBtb2RlLT5j bG9jayAqIGRpc3BsYXlfaW5mby0+YnBjICogMyAvIDEwMDA7Cj4gKwl1MzIgYWN0dWFsLCByYXRl LCBzaW5rX21heCwgc291cmNlX21heCA9IDA7Cj4gKwl1OCBsYW5lcywgaTsKPiArCj4gKwkvKiBm aW5kIHRoZSBydW5uaW5nIHBvcnQgKi8KPiArCWZvciAoaSA9IDA7IGkgPCBkcC0+cG9ydHM7IGkr Kykgewo+ICsJCWlmIChkcC0+cG9ydFtpXS0+cGh5X3N0YXR1cykgewo+ICsJCQlzb3VyY2VfbWF4 ID0gZHAtPnBvcnRbaV0tPmNhcF9sYW5lczsKPiArCQkJYnJlYWs7Cj4gKwkJfQo+ICsJfQo+ICsK PiArCXNpbmtfbWF4ID0gZHJtX2RwX21heF9sYW5lX2NvdW50KGRwLT5kcGNkKTsKPiArCWxhbmVz ID0gbWluKHNvdXJjZV9tYXgsIHNpbmtfbWF4KTsKPiArCj4gKwlzb3VyY2VfbWF4ID0gZHJtX2Rw X2J3X2NvZGVfdG9fbGlua19yYXRlKENETl9EUF9NQVhfTElOS19SQVRFKTsKPiArCXNpbmtfbWF4 ID0gZHJtX2RwX21heF9saW5rX3JhdGUoZHAtPmRwY2QpOwo+ICsJcmF0ZSA9IG1pbihzb3VyY2Vf bWF4LCBzaW5rX21heCk7Cj4gKwo+ICsJYWN0dWFsID0gcmF0ZSAqIGxhbmVzIC8gMTAwOwo+ICsK PiArCS8qIGVmZmljaWVuY3kgaXMgYWJvdXQgMC44ICovCj4gKwlhY3R1YWwgPSBhY3R1YWwgKiA4 IC8gMTA7Cj4gKwo+ICsJaWYgKHJlcXVlc3RlZCA+IGFjdHVhbCkgewo+ICsJCWRldl9kYmcoZHAt PmRldiwgInJlcXVlc3RlZD0lZCwgYWN0dWFsPSVkLCBjbG9jaz0lZFxuIiwKPiArCQkJcmVxdWVz dGVkLCBhY3R1YWwsIG1vZGUtPmNsb2NrKTsKPiArCQlyZXR1cm4gTU9ERV9DTE9DS19ISUdIOwo+ ICsJfQo+ICsKPiArCXJldHVybiBNT0RFX09LOwo+ICt9Cj4gKwo+ICtzdGF0aWMgc3RydWN0IGRy bV9jb25uZWN0b3JfaGVscGVyX2Z1bmNzIGNkbl9kcF9jb25uZWN0b3JfaGVscGVyX2Z1bmNzID0g ewo+ICsJLmdldF9tb2RlcyA9IGNkbl9kcF9jb25uZWN0b3JfZ2V0X21vZGVzLAo+ICsJLmJlc3Rf ZW5jb2RlciA9IGNkbl9kcF9jb25uZWN0b3JfYmVzdF9lbmNvZGVyLAo+ICsJLm1vZGVfdmFsaWQg PSBjZG5fZHBfY29ubmVjdG9yX21vZGVfdmFsaWQsCj4gK307Cj4gKwo+ICtzdGF0aWMgdm9pZCBj ZG5fZHBfY29tbWl0KHN0cnVjdCBkcm1fZW5jb2RlciAqZW5jb2RlcikKPiArewo+ICsJc3RydWN0 IGNkbl9kcF9kZXZpY2UgKmRwID0gZW5jb2Rlcl90b19kcChlbmNvZGVyKTsKPiArCWludCByZXQ7 Cj4gKwo+ICsJcmV0ID0gY2RuX2RwX3RyYWluaW5nX3N0YXJ0KGRwKTsKPiArCWlmIChyZXQpCj4g KwkJcmV0dXJuOwo+ICsKPiArCXJldCA9IGNkbl9kcF9nZXRfdHJhaW5pbmdfc3RhdHVzKGRwKTsK PiArCWlmIChyZXQpCj4gKwkJcmV0dXJuOwo+ICsKPiArCWRldl9pbmZvKGRwLT5kZXYsICJyYXRl OjB4JXgsIGxhbmVzOiVkXG4iLAo+ICsJCSBkcC0+bGluay5yYXRlLCBkcC0+bGluay5udW1fbGFu ZXMpOwo+ICsKPiArCWlmIChjZG5fZHBfc2V0X3ZpZGVvX3N0YXR1cyhkcCwgQ09OVFJPTF9WSURF T19JRExFKSkKPiArCQlyZXR1cm47Cj4gKwo+ICsJaWYgKGNkbl9kcF9jb25maWdfdmlkZW8oZHAp KQo+ICsJCXJldHVybjsKPiArCj4gKwlpZiAoY2RuX2RwX3NldF92aWRlb19zdGF0dXMoZHAsIENP TlRST0xfVklERU9fVkFMSUQpKQo+ICsJCXJldHVybjsKPiArCj4gKwlkcC0+ZHBtc19tb2RlID0g RFJNX01PREVfRFBNU19PTjsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgY2RuX2RwX2VuY29kZXJf bW9kZV9zZXQoc3RydWN0IGRybV9lbmNvZGVyICplbmNvZGVyLAo+ICsJCQkJICAgIHN0cnVjdCBk cm1fZGlzcGxheV9tb2RlICptb2RlLAo+ICsJCQkJICAgIHN0cnVjdCBkcm1fZGlzcGxheV9tb2Rl ICphZGp1c3RlZCkKPiArewo+ICsJc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwID0gZW5jb2Rlcl90 b19kcChlbmNvZGVyKTsKPiArCXN0cnVjdCBkcm1fZGlzcGxheV9pbmZvICpkaXNwbGF5X2luZm8g PSAmZHAtPmNvbm5lY3Rvci5kaXNwbGF5X2luZm87Cj4gKwlzdHJ1Y3Qgcm9ja2NoaXBfY3J0Y19z dGF0ZSAqc3RhdGU7Cj4gKwlzdHJ1Y3QgdmlkZW9faW5mbyAqdmlkZW8gPSAmZHAtPnZpZGVvX2lu Zm87Cj4gKwlpbnQgcmV0LCB2YWw7Cj4gKwo+ICsJc3dpdGNoIChkaXNwbGF5X2luZm8tPmJwYykg ewo+ICsJY2FzZSAxNjoKPiArCWNhc2UgMTI6Cj4gKwljYXNlIDEwOgo+ICsJCXZpZGVvLT5jb2xv cl9kZXB0aCA9IDEwOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSA2Ogo+ICsJCXZpZGVvLT5jb2xvcl9k ZXB0aCA9IDY7Cj4gKwkJYnJlYWs7Cj4gKwlkZWZhdWx0Ogo+ICsJCXZpZGVvLT5jb2xvcl9kZXB0 aCA9IDg7Cj4gKwkJYnJlYWs7Cj4gKwl9Cj4gKwo+ICsJdmlkZW8tPmNvbG9yX2ZtdCA9IFBYTF9S R0I7Cj4gKwo+ICsJdmlkZW8tPnZfc3luY19wb2xhcml0eSA9ICEhKG1vZGUtPmZsYWdzICYgRFJN X01PREVfRkxBR19OVlNZTkMpOwo+ICsJdmlkZW8tPmhfc3luY19wb2xhcml0eSA9ICEhKG1vZGUt PmZsYWdzICYgRFJNX01PREVfRkxBR19OSFNZTkMpOwo+ICsKPiArCXJldCA9IGRybV9vZl9lbmNv ZGVyX2FjdGl2ZV9lbmRwb2ludF9pZChkcC0+ZGV2LT5vZl9ub2RlLCBlbmNvZGVyKTsKPiArCWlm IChyZXQgPCAwKSB7Cj4gKwkJZGV2X2VycihkcC0+ZGV2LCAiQ291bGQgbm90IGdldCB2b3AgaWQs ICVkIiwgcmV0KTsKPiArCQlyZXR1cm47Cj4gKwl9Cj4gKwo+ICsJZGV2X2RiZyhkcC0+ZGV2LCAi dm9wICVzIG91dHB1dCB0byBjZG4tZHBcbiIsIChyZXQpID8gIkxJVCIgOiAiQklHIik7Cj4gKwlz dGF0ZSA9IHRvX3JvY2tjaGlwX2NydGNfc3RhdGUoZW5jb2Rlci0+Y3J0Yy0+c3RhdGUpOwo+ICsJ aWYgKHJldCkgewo+ICsJCXZhbCA9IERQX1NFTF9WT1BfTElUIHwgKERQX1NFTF9WT1BfTElUIDw8 IDE2KTsKPiArCQlzdGF0ZS0+b3V0cHV0X21vZGUgPSBST0NLQ0hJUF9PVVRfTU9ERV9QODg4Owo+ ICsJfSBlbHNlIHsKPiArCQl2YWwgPSBEUF9TRUxfVk9QX0xJVCA8PCAxNjsKPiArCQlzdGF0ZS0+ b3V0cHV0X21vZGUgPSBST0NLQ0hJUF9PVVRfTU9ERV9BQUFBOwo+ICsJfQo+ICsKPiArCXJldCA9 IGNkbl9kcF9ncmZfd3JpdGUoZHAsIEdSRl9TT0NfQ09OOSwgdmFsKTsKPiArCWlmIChyZXQpCj4g KwkJcmV0dXJuOwo+ICsKPiArCW1lbWNweSgmZHAtPm1vZGUsIGFkanVzdGVkLCBzaXplb2YoKm1v ZGUpKTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgY2RuX2RwX2VuY29kZXJfZW5hYmxlKHN0cnVj dCBkcm1fZW5jb2RlciAqZW5jb2RlcikKPiArewo+ICsJc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRw ID0gZW5jb2Rlcl90b19kcChlbmNvZGVyKTsKPiArCj4gKwlpZiAoZHAtPmRwbXNfbW9kZSAhPSBE Uk1fTU9ERV9EUE1TX09OKQo+ICsJCWNkbl9kcF9jb21taXQoZW5jb2Rlcik7Cj4gK30KPiArCj4g K3N0YXRpYyB2b2lkIGNkbl9kcF9lbmNvZGVyX2Rpc2FibGUoc3RydWN0IGRybV9lbmNvZGVyICpl bmNvZGVyKQo+ICt7Cj4gKwlzdHJ1Y3QgY2RuX2RwX2RldmljZSAqZHAgPSBlbmNvZGVyX3RvX2Rw KGVuY29kZXIpOwo+ICsKPiArCWRwLT5kcG1zX21vZGUgPSBEUk1fTU9ERV9EUE1TX09GRjsKPiAr fQo+ICsKPiArc3RhdGljIGludAo+ICtjZG5fZHBfZW5jb2Rlcl9hdG9taWNfY2hlY2soc3RydWN0 IGRybV9lbmNvZGVyICplbmNvZGVyLAo+ICsJCQkgICAgc3RydWN0IGRybV9jcnRjX3N0YXRlICpj cnRjX3N0YXRlLAo+ICsJCQkgICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3Rh dGUpCj4gK3sKPiArCXN0cnVjdCByb2NrY2hpcF9jcnRjX3N0YXRlICpzID0gdG9fcm9ja2NoaXBf Y3J0Y19zdGF0ZShjcnRjX3N0YXRlKTsKPiArCj4gKwlzLT5vdXRwdXRfbW9kZSA9IFJPQ0tDSElQ X09VVF9NT0RFX0FBQUE7Cj4gKwlzLT5vdXRwdXRfdHlwZSA9IERSTV9NT0RFX0NPTk5FQ1RPUl9E aXNwbGF5UG9ydDsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIHN0cnVjdCBk cm1fZW5jb2Rlcl9oZWxwZXJfZnVuY3MgY2RuX2RwX2VuY29kZXJfaGVscGVyX2Z1bmNzID0gewo+ ICsJLm1vZGVfc2V0ID0gY2RuX2RwX2VuY29kZXJfbW9kZV9zZXQsCj4gKwkuZW5hYmxlID0gY2Ru X2RwX2VuY29kZXJfZW5hYmxlLAo+ICsJLmRpc2FibGUgPSBjZG5fZHBfZW5jb2Rlcl9kaXNhYmxl LAo+ICsJLmF0b21pY19jaGVjayA9IGNkbl9kcF9lbmNvZGVyX2F0b21pY19jaGVjaywKPiArfTsK PiArCj4gK3N0YXRpYyBzdHJ1Y3QgZHJtX2VuY29kZXJfZnVuY3MgY2RuX2RwX2VuY29kZXJfZnVu Y3MgPSB7Cj4gKwkuZGVzdHJveSA9IGRybV9lbmNvZGVyX2NsZWFudXAsCj4gK307Cj4gKwo+ICtz dGF0aWMgaW50IGNkbl9kcF9maXJtd2FyZV9pbml0KHN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCkK PiArewo+ICsJaW50IHJldDsKPiArCWNvbnN0IHUzMiAqaXJhbV9kYXRhLCAqZHJhbV9kYXRhOwo+ ICsJY29uc3Qgc3RydWN0IGZpcm13YXJlICpmdyA9IGRwLT5mdzsKPiArCWNvbnN0IHN0cnVjdCBj ZG5fZmlybXdhcmVfaGVhZGVyICpoZHI7Cj4gKwo+ICsJaGRyID0gKHN0cnVjdCBjZG5fZmlybXdh cmVfaGVhZGVyICopZnctPmRhdGE7Cj4gKwlpZiAoZnctPnNpemUgIT0gbGUzMl90b19jcHUoaGRy LT5zaXplX2J5dGVzKSkgewo+ICsJCWRldl9lcnIoZHAtPmRldiwgImZpcm13YXJlIGlzIGludmFs aWRcbiIpOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsJfQo+ICsKPiArCWlyYW1fZGF0YSA9IChj b25zdCB1MzIgKikoZnctPmRhdGEgKyBoZHItPmhlYWRlcl9zaXplKTsKPiArCWRyYW1fZGF0YSA9 IChjb25zdCB1MzIgKikoZnctPmRhdGEgKyBoZHItPmhlYWRlcl9zaXplICsgaGRyLT5pcmFtX3Np emUpOwo+ICsKPiArCXJldCA9IGNkbl9kcF9sb2FkX2Zpcm13YXJlKGRwLCBpcmFtX2RhdGEsIGhk ci0+aXJhbV9zaXplLAo+ICsJCQkJICAgZHJhbV9kYXRhLCBoZHItPmRyYW1fc2l6ZSk7Cj4gKwlp ZiAocmV0KQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJcmV0ID0gY2RuX2RwX3NldF9maXJtd2Fy ZV9hY3RpdmUoZHAsIHRydWUpOwo+ICsJaWYgKHJldCkgewo+ICsJCWRldl9lcnIoZHAtPmRldiwg ImFjdGl2ZSB1Y3B1IGZhaWxlZDogJWRcbiIsIHJldCk7Cj4gKwkJcmV0dXJuIHJldDsKPiArCX0K PiArCj4gKwlyZXR1cm4gY2RuX2RwX2V2ZW50X2NvbmZpZyhkcCk7Cj4gK30KPiArCj4gK3N0YXRp YyBpbnQgY2RuX2RwX2luaXQoc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwKQo+ICt7Cj4gKwlzdHJ1 Y3QgZGV2aWNlICpkZXYgPSBkcC0+ZGV2Owo+ICsJc3RydWN0IGRldmljZV9ub2RlICpucCA9IGRl di0+b2Zfbm9kZTsKPiArCXN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYgPSB0b19wbGF0Zm9y bV9kZXZpY2UoZGV2KTsKPiArCXN0cnVjdCByZXNvdXJjZSAqcmVzOwo+ICsJaW50IHJldDsKPiAr Cj4gKwlkcC0+Z3JmID0gc3lzY29uX3JlZ21hcF9sb29rdXBfYnlfcGhhbmRsZShucCwgInJvY2tj aGlwLGdyZiIpOwo+ICsJaWYgKElTX0VSUihkcC0+Z3JmKSkgewo+ICsJCWRldl9lcnIoZGV2LCAi Y2RuLWRwIG5lZWRzIHJvY2tjaGlwLGdyZiBwcm9wZXJ0eVxuIik7Cj4gKwkJcmV0dXJuIFBUUl9F UlIoZHAtPmdyZik7Cj4gKwl9Cj4gKwo+ICsJcmVzID0gcGxhdGZvcm1fZ2V0X3Jlc291cmNlKHBk ZXYsIElPUkVTT1VSQ0VfTUVNLCAwKTsKPiArCWRwLT5yZWdzID0gZGV2bV9pb3JlbWFwX3Jlc291 cmNlKGRldiwgcmVzKTsKPiArCWlmIChJU19FUlIoZHAtPnJlZ3MpKSB7Cj4gKwkJZGV2X2Vycihk ZXYsICJpb3JlbWFwIHJlZyBmYWlsZWRcbiIpOwo+ICsJCXJldHVybiBQVFJfRVJSKGRwLT5yZWdz KTsKPiArCX0KPiArCj4gKwlkcC0+Y29yZV9jbGsgPSBkZXZtX2Nsa19nZXQoZGV2LCAiY29yZS1j bGsiKTsKPiArCWlmIChJU19FUlIoZHAtPmNvcmVfY2xrKSkgewo+ICsJCWRldl9lcnIoZGV2LCAi Y2Fubm90IGdldCBjb3JlX2Nsa19kcFxuIik7Cj4gKwkJcmV0dXJuIFBUUl9FUlIoZHAtPmNvcmVf Y2xrKTsKPiArCX0KPiArCj4gKwlkcC0+cGNsayA9IGRldm1fY2xrX2dldChkZXYsICJwY2xrIik7 Cj4gKwlpZiAoSVNfRVJSKGRwLT5wY2xrKSkgewo+ICsJCWRldl9lcnIoZGV2LCAiY2Fubm90IGdl dCBwY2xrXG4iKTsKPiArCQlyZXR1cm4gUFRSX0VSUihkcC0+cGNsayk7Cj4gKwl9Cj4gKwo+ICsJ ZHAtPnNwZGlmX2NsayA9IGRldm1fY2xrX2dldChkZXYsICJzcGRpZiIpOwo+ICsJaWYgKElTX0VS UihkcC0+c3BkaWZfY2xrKSkgewo+ICsJCWRldl9lcnIoZGV2LCAiY2Fubm90IGdldCBzcGRpZl9j bGtcbiIpOwo+ICsJCXJldHVybiBQVFJfRVJSKGRwLT5zcGRpZl9jbGspOwo+ICsJfQo+ICsKPiAr CWRwLT5ncmZfY2xrID0gZGV2bV9jbGtfZ2V0KGRldiwgImdyZiIpOwo+ICsJaWYgKElTX0VSUihk cC0+Z3JmX2NsaykpIHsKPiArCQlkZXZfZXJyKGRldiwgImNhbm5vdCBnZXQgZ3JmIGNsa1xuIik7 Cj4gKwkJcmV0dXJuIFBUUl9FUlIoZHAtPmdyZl9jbGspOwo+ICsJfQo+ICsKPiArCWRwLT5zcGRp Zl9yc3QgPSBkZXZtX3Jlc2V0X2NvbnRyb2xfZ2V0KGRldiwgInNwZGlmIik7Cj4gKwlpZiAoSVNf RVJSKGRwLT5zcGRpZl9yc3QpKSB7Cj4gKwkJZGV2X2VycihkZXYsICJubyBzcGRpZiByZXNldCBj b250cm9sIGZvdW5kXG4iKTsKPiArCQlyZXR1cm4gUFRSX0VSUihkcC0+c3BkaWZfcnN0KTsKPiAr CX0KPiArCj4gKwlkcC0+ZHBtc19tb2RlID0gRFJNX01PREVfRFBNU19PRkY7Cj4gKwo+ICsJcmV0 ID0gY2RuX2RwX2Nsa19lbmFibGUoZHApOwo+ICsJaWYgKHJldCA8IDApCj4gKwkJcmV0dXJuIHJl dDsKPiArCj4gKwljZG5fZHBfY2xvY2tfcmVzZXQoZHApOwo+ICsKPiArCXJldHVybiAwOwo+ICt9 Cj4gKwo+ICtzdGF0aWMgaW50IGNkbl9kcF9hdWRpb19od19wYXJhbXMoc3RydWN0IGRldmljZSAq ZGV2LCAgdm9pZCAqZGF0YSwKPiArCQkJCSAgc3RydWN0IGhkbWlfY29kZWNfZGFpZm10ICpkYWlm bXQsCj4gKwkJCQkgIHN0cnVjdCBoZG1pX2NvZGVjX3BhcmFtcyAqcGFyYW1zKQo+ICt7Cj4gKwlz dHJ1Y3QgY2RuX2RwX2RldmljZSAqZHAgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPiArCXN0cnVj dCBhdWRpb19pbmZvIGF1ZGlvID0gewo+ICsJCS5zYW1wbGVfd2lkdGggPSBwYXJhbXMtPnNhbXBs ZV93aWR0aCwKPiArCQkuc2FtcGxlX3JhdGUgPSBwYXJhbXMtPnNhbXBsZV9yYXRlLAo+ICsJCS5j aGFubmVscyA9IHBhcmFtcy0+Y2hhbm5lbHMsCj4gKwl9Owo+ICsJaW50IHJldDsKPiArCj4gKwlp ZiAoIWRwLT5lbmNvZGVyLmNydGMpCj4gKwkJcmV0dXJuIC1FTk9ERVY7Cj4gKwo+ICsJc3dpdGNo IChkYWlmbXQtPmZtdCkgewo+ICsJY2FzZSBIRE1JX0kyUzoKPiArCQlhdWRpby5mb3JtYXQgPSBB Rk1UX0kyUzsKPiArCQlicmVhazsKPiArCWNhc2UgSERNSV9TUERJRjoKPiArCQlhdWRpby5mb3Jt YXQgPSBBRk1UX1NQRElGOwo+ICsJCWJyZWFrOwo+ICsJZGVmYXVsdDoKPiArCQlkZXZfZXJyKGRl diwgIiVzOiBJbnZhbGlkIGZvcm1hdCAlZFxuIiwgX19mdW5jX18sIGRhaWZtdC0+Zm10KTsKPiAr CQlyZXR1cm4gLUVJTlZBTDsKPiArCX0KPiArCj4gKwlyZXQgPSBjZG5fZHBfYXVkaW9fY29uZmln KGRwLCAmYXVkaW8pOwo+ICsJaWYgKCFyZXQpCj4gKwkJZHAtPmF1ZGlvX2luZm8gPSBhdWRpbzsK PiArCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCBjZG5fZHBfYXVkaW9f c2h1dGRvd24oc3RydWN0IGRldmljZSAqZGV2LCB2b2lkICpkYXRhKQo+ICt7Cj4gKwlzdHJ1Y3Qg Y2RuX2RwX2RldmljZSAqZHAgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPiArCWludCByZXQ7Cj4g Kwo+ICsJaWYgKCFkcC0+ZW5jb2Rlci5jcnRjKQo+ICsJCXJldHVybjsKPiArCj4gKwlyZXQgPSBj ZG5fZHBfYXVkaW9fc3RvcChkcCwgJmRwLT5hdWRpb19pbmZvKTsKPiArCWlmICghcmV0KQo+ICsJ CWRwLT5hdWRpb19pbmZvLmZvcm1hdCA9IEFGTVRfVU5VU0VEOwo+ICt9Cj4gKwo+ICtzdGF0aWMg aW50IGNkbl9kcF9hdWRpb19kaWdpdGFsX211dGUoc3RydWN0IGRldmljZSAqZGV2LCB2b2lkICpk YXRhLAo+ICsJCQkJICAgICBib29sIGVuYWJsZSkKPiArewo+ICsJc3RydWN0IGNkbl9kcF9kZXZp Y2UgKmRwID0gZGV2X2dldF9kcnZkYXRhKGRldik7Cj4gKwo+ICsJaWYgKCFkcC0+ZW5jb2Rlci5j cnRjKQo+ICsJCXJldHVybiAtRU5PREVWOwo+ICsKPiArCXJldHVybiBjZG5fZHBfYXVkaW9fbXV0 ZShkcCwgZW5hYmxlKTsKPiArfQo+ICsKPiArc3RhdGljIGludCBjZG5fZHBfYXVkaW9fZ2V0X2Vs ZChzdHJ1Y3QgZGV2aWNlICpkZXYsIHZvaWQgKmRhdGEsCj4gKwkJCQl1OCAqYnVmLCBzaXplX3Qg bGVuKQo+ICt7Cj4gKwlzdHJ1Y3QgY2RuX2RwX2RldmljZSAqZHAgPSBkZXZfZ2V0X2RydmRhdGEo ZGV2KTsKPiArCXN0cnVjdCBkcm1fbW9kZV9jb25maWcgKmNvbmZpZyA9ICZkcC0+ZW5jb2Rlci5k ZXYtPm1vZGVfY29uZmlnOwo+ICsJc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcjsKPiAr CWludCByZXQgPSAtRU5PREVWOwo+ICsKPiArCW11dGV4X2xvY2soJmNvbmZpZy0+bXV0ZXgpOwo+ ICsJbGlzdF9mb3JfZWFjaF9lbnRyeShjb25uZWN0b3IsICZjb25maWctPmNvbm5lY3Rvcl9saXN0 LCBoZWFkKSB7Cj4gKwkJaWYgKCZkcC0+ZW5jb2RlciA9PSBjb25uZWN0b3ItPmVuY29kZXIpIHsK PiArCQkJbWVtY3B5KGJ1ZiwgY29ubmVjdG9yLT5lbGQsCj4gKwkJCSAgICAgICBtaW4oc2l6ZW9m KGNvbm5lY3Rvci0+ZWxkKSwgbGVuKSk7Cj4gKwkJCXJldCA9IDA7Cj4gKwkJfQo+ICsJfQo+ICsJ bXV0ZXhfdW5sb2NrKCZjb25maWctPm11dGV4KTsKPiArCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4g Kwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGhkbWlfY29kZWNfb3BzIGF1ZGlvX2NvZGVjX29wcyA9 IHsKPiArCS5od19wYXJhbXMgPSBjZG5fZHBfYXVkaW9faHdfcGFyYW1zLAo+ICsJLmF1ZGlvX3No dXRkb3duID0gY2RuX2RwX2F1ZGlvX3NodXRkb3duLAo+ICsJLmRpZ2l0YWxfbXV0ZSA9IGNkbl9k cF9hdWRpb19kaWdpdGFsX211dGUsCj4gKwkuZ2V0X2VsZCA9IGNkbl9kcF9hdWRpb19nZXRfZWxk LAo+ICt9Owo+ICsKPiArc3RhdGljIGludCBjZG5fZHBfYXVkaW9fY29kZWNfaW5pdChzdHJ1Y3Qg Y2RuX2RwX2RldmljZSAqZHAsCj4gKwkJCQkgICBzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gK3sKPiAr CXN0cnVjdCBoZG1pX2NvZGVjX3BkYXRhIGNvZGVjX2RhdGEgPSB7Cj4gKwkJLmkycyA9IDEsCj4g KwkJLnNwZGlmID0gMSwKPiArCQkub3BzID0gJmF1ZGlvX2NvZGVjX29wcywKPiArCQkubWF4X2ky c19jaGFubmVscyA9IDgsCj4gKwl9Owo+ICsKPiArCWRwLT5hdWRpb19wZGV2ID0gcGxhdGZvcm1f ZGV2aWNlX3JlZ2lzdGVyX2RhdGEoCj4gKwkJCSBkZXYsIEhETUlfQ09ERUNfRFJWX05BTUUsIFBM QVRGT1JNX0RFVklEX0FVVE8sCj4gKwkJCSAmY29kZWNfZGF0YSwgc2l6ZW9mKGNvZGVjX2RhdGEp KTsKPiArCj4gKwlyZXR1cm4gUFRSX0VSUl9PUl9aRVJPKGRwLT5hdWRpb19wZGV2KTsKPiArfQo+ ICsKPiArc3RhdGljIGludCBjZG5fZHBfZ2V0X2NhcF9sYW5lcyhzdHJ1Y3QgY2RuX2RwX2Rldmlj ZSAqZHAsCj4gKwkJCQlzdHJ1Y3QgZXh0Y29uX2RldiAqZWRldikKPiArewo+ICsJYm9vbCBkZnAs IGRwdHg7Cj4gKwl1OCBsYW5lczsKPiArCj4gKwlkZnAgPSBleHRjb25fZ2V0X3N0YXRlKGVkZXYs IEVYVENPTl9VU0JfSE9TVCk7Cj4gKwlkcHR4ID0gZXh0Y29uX2dldF9zdGF0ZShlZGV2LCBFWFRD T05fRElTUF9EUCk7Cj4gKwo+ICsJaWYgKGRmcCAmJiBkcHR4KQo+ICsJCWxhbmVzID0gMjsKPiAr CWVsc2UgaWYgKGRwdHgpCj4gKwkJbGFuZXMgPSA0Owo+ICsJZWxzZQo+ICsJCWxhbmVzID0gMDsK PiArCj4gKwlyZXR1cm4gbGFuZXM7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgY2RuX2RwX3BkX2V2 ZW50KHN0cnVjdCBub3RpZmllcl9ibG9jayAqbmIsCj4gKwkJCSAgIHVuc2lnbmVkIGxvbmcgZXZl bnQsIHZvaWQgKnByaXYpCj4gK3sKPiArCXN0cnVjdCBjZG5fZHBfcG9ydCAqcG9ydDsKPiArCj4g Kwlwb3J0ID0gY29udGFpbmVyX29mKG5iLCBzdHJ1Y3QgY2RuX2RwX3BvcnQsIGV2ZW50X25iKTsK PiArCj4gKwlzY2hlZHVsZV9kZWxheWVkX3dvcmsoJnBvcnQtPmV2ZW50X3dxLCAwKTsKPiArCj4g KwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgY2RuX2RwX3BkX2V2ZW50X3dxKHN0 cnVjdCB3b3JrX3N0cnVjdCAqd29yaykKPiArewo+ICsJc3RydWN0IGNkbl9kcF9wb3J0ICpwb3J0 ID0gY29udGFpbmVyX29mKHdvcmssIHN0cnVjdCBjZG5fZHBfcG9ydCwKPiArCQkJCQkJZXZlbnRf d3Eud29yayk7Cj4gKwl1bmlvbiBleHRjb25fcHJvcGVydHlfdmFsdWUgcHJvcGVydHk7Cj4gKwlz dHJ1Y3QgY2RuX2RwX2RldmljZSAqZHAgPSBwb3J0LT5kcDsKPiArCXU4IG5ld19jYXBfbGFuZXMs IHNpbmtfY291bnQsIGk7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCW5ld19jYXBfbGFuZXMgPSBjZG5f ZHBfZ2V0X2NhcF9sYW5lcyhkcCwgcG9ydC0+ZXh0Y29uKTsKPiArCj4gKwlpZiAobmV3X2NhcF9s YW5lcyA9PSBwb3J0LT5jYXBfbGFuZXMpIHsKPiArCQlkZXZfZGJnKGRwLT5kZXYsICJsYW5lcyBj b3VudCBkb2VzIG5vdCBjaGFuZ2U6ICVkXG4iLAo+ICsJCQluZXdfY2FwX2xhbmVzKTsKPiArCj4g KwkJaWYgKCFuZXdfY2FwX2xhbmVzKQo+ICsJCQlyZXR1cm47Cj4gKwo+ICsJCS8qCj4gKwkJICog UmVhZCB0aGUgc2luayBjb3VudCBmcm9tIERQQ0QsIGlmIHNpbmsgY291bnQgYmVjb21lIDAsIHRo aXMKPiArCQkgKiBwaHkgY291bGQgYmUgcG93ZXIgb2ZmLgo+ICsJCSAqLwo+ICsJCXJldCA9IGNk bl9kcF9kcGNkX3JlYWQoZHAsIERQX1NJTktfQ09VTlQsCj4gKwkJCQkgICAgICAgJnNpbmtfY291 bnQsIDEpOwoKCQlyZXQgPSBjZG5fZHBfZHBjZF9yZWFkKGRwLCBEUF9TSU5LX0NPVU5ULCAmc2lu a19jb3VudCwgMSk7CgogIHRoaXMgbGluZSBpcyBub3Qgb3ZlciA4MCBjaGFyYWN0ZXJzLCBubyBu ZWVkIHRvIGJlY29tZSB0d28gbGluZXMuCgo+ICsJCWlmIChyZXQgfHwgc2lua19jb3VudCkKPiAr CQkJcmV0dXJuOwo+ICsKPiArCQluZXdfY2FwX2xhbmVzID0gMDsKPiArCX0KPiArCj4gKwlpZiAo IW5ld19jYXBfbGFuZXMpIHsKPiArCQlyZXQgPSBwaHlfcG93ZXJfb2ZmKHBvcnQtPnBoeSk7Cj4g KwkJaWYgKHJldCkgewo+ICsJCQlkZXZfZXJyKGRwLT5kZXYsICJwaHkgcG93ZXIgb2ZmIGZhaWxl ZDogJWQiLCByZXQpOwo+ICsJCQlyZXR1cm47Cj4gKwkJfQo+ICsJCXBvcnQtPnBoeV9zdGF0dXMg PSBmYWxzZTsKPiArCQlwb3J0LT5jYXBfbGFuZXMgPSAwOwo+ICsJCWZvciAoaSA9IDA7IGkgPCBk cC0+cG9ydHM7IGkrKykgewo+ICsJCQlpZiAoZHAtPnBvcnRbaV0tPnBoeV9zdGF0dXMpCj4gKwkJ CQlyZXR1cm47Cj4gKwkJfQo+ICsKPiArCQlyZXQgPSBjZG5fZHBfZ3JmX3dyaXRlKGRwLCBHUkZf U09DX0NPTjI2LAo+ICsJCQkJICAgICAgIERQVFhfSFBEX1NFTF9NQVNLIHwgRFBUWF9IUERfREVM KTsKPiArCQlpZiAocmV0KQo+ICsJCQlyZXR1cm47Cj4gKwo+ICsJCWRwLT5ocGRfc3RhdHVzID0g Y29ubmVjdG9yX3N0YXR1c19kaXNjb25uZWN0ZWQ7Cj4gKwkJZHJtX2hlbHBlcl9ocGRfaXJxX2V2 ZW50KGRwLT5kcm1fZGV2KTsKPiArCQljZG5fZHBfc2V0X2Zpcm13YXJlX2FjdGl2ZShkcCwgZmFs c2UpOwo+ICsJCXJldHVybjsKPiArCX0KPiArCj4gKwkvKiBpZiBvdGhlciBwaHkgaXMgcnVubmlu ZywgZG8gbm90IHRvdWNoIHRoZSBocGRfc3RhdHVzLCBhbmQgcmV0dXJuICovCj4gKwlmb3IgKGkg PSAwOyBpIDwgZHAtPnBvcnRzOyBpKyspIHsKPiArCQlpZiAoZHAtPnBvcnRbaV0tPnBoeV9zdGF0 dXMpIHsKPiArCQkJZGV2X3dhcm4oZHAtPmRldiwgImJ1c3ksIHBoeVslZF0gaXMgcnVubmluZyIs Cj4gKwkJCQkgZHAtPnBvcnRbaV0tPmlkKTsKPiArCQkJcmV0dXJuOwo+ICsJCX0KPiArCX0KPiAr Cj4gKwlpZiAoIWRwLT5md19sb2FkZWQpIHsKPiArCQlyZXQgPSByZXF1ZXN0X2Zpcm13YXJlKCZk cC0+ZncsIENETl9EUF9GSVJNV0FSRSwgZHAtPmRldik7Cj4gKwkJaWYgKHJldCA9PSAtRU5PRU5U ICYmIGRwLT5md193YWl0IDw9IE1BWF9GV19XQUlUX1NFQ1MpIHsKPiArCQkJdW5zaWduZWQgbG9u ZyB0aW1lID0gbXNlY3NfdG9famlmZmllcyhkcC0+Zndfd2FpdCAqIEhaKTsKPiArCj4gKwkJCS8q Cj4gKwkJCSAqIElmIGNhbiBub3QgZmluZCB0aGUgZmlsZSwgcmV0cnkgdG8gbG9hZCB0aGUgZmly bXdhcmUKPiArCQkJICogaW4gc2V2ZXJhbCBzZWNvbmRzLCBpZiBzdGlsbCBmYWlsZWQgYWZ0ZXIg MSBtaW51dGUsCj4gKwkJCSAqIGdpdmUgdXAuCj4gKwkJCSAqLwo+ICsJCQlzY2hlZHVsZV9kZWxh eWVkX3dvcmsoJnBvcnQtPmV2ZW50X3dxLCB0aW1lKTsKPiArCQkJZHAtPmZ3X3dhaXQgKj0gMjsK PiArCQkJcmV0dXJuOwo+ICsJCX0gZWxzZSBpZiAocmV0KSB7Cj4gKwkJCWRldl9lcnIoZHAtPmRl diwgImZhaWxlZCB0byByZXF1ZXN0IGZpcm13YXJlOiAlZFxuIiwKPiArCQkJCXJldCk7Cj4gKwkJ CXJldHVybjsKPiArCQl9Cj4gKwl9IGVsc2Ugewo+ICsJCWNkbl9kcF9zZXRfZmlybXdhcmVfYWN0 aXZlKGRwLCB0cnVlKTsKPiArCX0KPiArCj4gKwlyZXQgPSBjZG5fZHBfZ3JmX3dyaXRlKGRwLCBH UkZfU09DX0NPTjI2LAo+ICsJCQkgICAgICAgKHBvcnQtPmlkIDw8IFVQSFlfU0VMX0JJVCkgfCBV UEhZX1NFTF9NQVNLKTsKPiArCWlmIChyZXQpCj4gKwkJZ290byBlcnJfcGh5Owo+ICsKPiArCXJl dCA9IHBoeV9wb3dlcl9vbihwb3J0LT5waHkpOwo+ICsJaWYgKHJldCkgewo+ICsJCWRldl9lcnIo ZHAtPmRldiwgInBoeSBwb3dlciBvbiBmYWlsZWQ6ICVkXG4iLCByZXQpOwo+ICsJCWdvdG8gZXJy X3BoeTsKPiArCX0KPiArCj4gKwlwb3J0LT5waHlfc3RhdHVzID0gdHJ1ZTsKPiArCj4gKwlpZiAo IWRwLT5md19sb2FkZWQpIHsKPiArCQlyZXQgPSBjZG5fZHBfZmlybXdhcmVfaW5pdChkcCk7Cj4g KwkJaWYgKHJldCkgewo+ICsJCQlkZXZfZXJyKGRwLT5kZXYsICJmaXJtd2FyZSBpbml0IGZhaWxl ZDogJWQiLCByZXQpOwo+ICsJCQlnb3RvIGVycl9maXJtd2FyZTsKPiArCQl9Cj4gKwkJcmVsZWFz ZV9maXJtd2FyZShkcC0+ZncpOwo+ICsJCWRwLT5md19sb2FkZWQgPSAxOwo+ICsJfQo+ICsKPiAr CXJldCA9IGNkbl9kcF9ncmZfd3JpdGUoZHAsIEdSRl9TT0NfQ09OMjYsCj4gKwkJCSAgICAgICBE UFRYX0hQRF9TRUxfTUFTSyB8IERQVFhfSFBEX1NFTCk7Cj4gKwlpZiAocmV0KQo+ICsJCWdvdG8g ZXJyX2Zpcm13YXJlOwo+ICsKPiArCXJldCA9IGNkbl9kcF9nZXRfaHBkX3N0YXR1cyhkcCk7Cj4g KwlpZiAocmV0IDw9IDApIHsKPiArCQlpZiAoIXJldCkKPiArCQkJZGV2X2VycihkcC0+ZGV2LCAi aHBkIGRvZXMgbm90IGV4aXN0XG4iKTsKPiArCQlnb3RvIGVycl9maXJtd2FyZTsKPiArCX0KPiAr Cj4gKwlyZXQgPSBleHRjb25fZ2V0X3Byb3BlcnR5KHBvcnQtPmV4dGNvbiwgRVhUQ09OX0RJU1Bf RFAsCj4gKwkJCQkgIEVYVENPTl9QUk9QX1VTQl9UWVBFQ19QT0xBUklUWSwgJnByb3BlcnR5KTsK PiArCWlmIChyZXQpIHsKPiArCQlkZXZfZXJyKGRwLT5kZXYsICJnZXQgcHJvcGVydHkgZmFpbGVk XG4iKTsKPiArCQlnb3RvIGVycl9maXJtd2FyZTsKPiArCX0KPiArCj4gKwlyZXQgPSBjZG5fZHBf c2V0X2hvc3RfY2FwKGRwLCBuZXdfY2FwX2xhbmVzLCBwcm9wZXJ0eS5pbnR2YWwpOwo+ICsJaWYg KHJldCkgewo+ICsJCWRldl9lcnIoZHAtPmRldiwgInNldCBob3N0IGNhcGFiaWxpdGllcyBmYWls ZWQ6ICVkXG4iLCByZXQpOwo+ICsJCWdvdG8gZXJyX2Zpcm13YXJlOwo+ICsJfQo+ICsKPiArCS8q Cj4gKwkgKiBOYXRpdmUgcmVhZCB3aXRoIHJldHJ5IGZvciBsaW5rIHN0YXR1cyBhbmQgcmVjZWl2 ZXIgY2FwYWJpbGl0eSByZWFkcwo+ICsJICogZm9yIGNhc2VzIHdoZXJlIHRoZSBzaW5rIG1heSBz dGlsbCBub3QgYmUgcmVhZHkuCj4gKwkgKgo+ICsJICogU2lua3MgYXJlICpzdXBwb3NlZCogdG8g Y29tZSB1cCB3aXRoaW4gMW1zIGZyb20gYW4gb2ZmIHN0YXRlLCBidXQKPiArCSAqIHNvbWUgRE9D S3MgbmVlZCBhYm91dCA1IHNlY29uZHMgdG8gcG93ZXIgdXAsIHNvIHJlYWQgdGhlIGRwY2QgZXZl cnkKPiArCSAqIDEwMG1zLCBpZiBjYW4gbm90IGdldCBhIGdvb2QgZHBjZCBpbiAxMCBzZWNvbmRz LCBnaXZlIHVwLgo+ICsJICovCj4gKwlmb3IgKGkgPSAwOyBpIDwgMTAwOyBpKyspIHsKPiArCQly ZXQgPSBjZG5fZHBfZHBjZF9yZWFkKGRwLCAweDAwMCwgZHAtPmRwY2QsCj4gKwkJCQkgICAgICAg RFBfUkVDRUlWRVJfQ0FQX1NJWkUpOwo+ICsJCWlmICghcmV0KSB7Cj4gKwkJCWRldl9kYmcoZHAt PmRldiwgImdldCBkcGNkIHN1Y2Nlc3MhXG4iKTsKPiArCj4gKwkJCS8qCj4gKwkJCSAqIENoZWNr IHNpbmsgY291bnQgaGVyZS4gVGhlbiBnb3RvIHBvd2VyIG9mZiBwaHksCj4gKwkJCSAqIGlmIHNp bmsgY291bnQgaXMgMC4KPiArCQkJICovCj4gKwkJCXJldCA9IGNkbl9kcF9kcGNkX3JlYWQoZHAs IERQX1NJTktfQ09VTlQsCj4gKwkJCQkJICAgICAgICZzaW5rX2NvdW50LCAxKTsKPiArCQkJaWYg KHJldCkKPiArCQkJCWNvbnRpbnVlOwo+ICsKPiArCQkJc2lua19jb3VudCA9IERQX0dFVF9TSU5L X0NPVU5UKHNpbmtfY291bnQpOwo+ICsJCQlpZiAoIXNpbmtfY291bnQpCj4gKwkJCQlnb3RvIGVy cl9maXJtd2FyZTsKPiArCj4gKwkJCXBvcnQtPmNhcF9sYW5lcyA9IG5ld19jYXBfbGFuZXM7Cj4g KwkJCWRwLT5ocGRfc3RhdHVzID0gY29ubmVjdG9yX3N0YXR1c19jb25uZWN0ZWQ7Cj4gKwkJCWRy bV9oZWxwZXJfaHBkX2lycV9ldmVudChkcC0+ZHJtX2Rldik7Cj4gKwkJCXJldHVybjsKPiArCQl9 IGVsc2UgaWYgKCFleHRjb25fZ2V0X3N0YXRlKHBvcnQtPmV4dGNvbiwgRVhUQ09OX0RJU1BfRFAp KSB7Cj4gKwkJCWJyZWFrOwo+ICsJCX0KPiArCQltc2xlZXAoMTAwKTsKPiArCX0KPiArCj4gKwlk ZXZfZXJyKGRwLT5kZXYsICJnZXQgZHBjZCBmYWlsZWQhXG4iKTsKPiArCj4gK2Vycl9maXJtd2Fy ZToKPiArCXJldCA9IHBoeV9wb3dlcl9vZmYocG9ydC0+cGh5KTsKPiArCWlmIChyZXQpCj4gKwkJ ZGV2X2VycihkcC0+ZGV2LCAicGh5IHBvd2VyIG9mZiBmYWlsZWQ6ICVkIiwgcmV0KTsKPiArCWVs c2UKPiArCQlwb3J0LT5waHlfc3RhdHVzID0gZmFsc2U7Cj4gKwo+ICtlcnJfcGh5Ogo+ICsJaWYg KGRwLT5md19sb2FkZWQpCj4gKwkJY2RuX2RwX3NldF9maXJtd2FyZV9hY3RpdmUoZHAsIGZhbHNl KTsKPiArCWVsc2UKPiArCQlyZWxlYXNlX2Zpcm13YXJlKGRwLT5mdyk7Cj4gK30KPiArCj4gK3N0 YXRpYyBpbnQgY2RuX2RwX2JpbmQoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlICpt YXN0ZXIsIHZvaWQgKmRhdGEpCj4gK3sKPiArCXN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCA9IGRl dl9nZXRfZHJ2ZGF0YShkZXYpOwo+ICsJc3RydWN0IGRybV9lbmNvZGVyICplbmNvZGVyOwo+ICsJ c3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcjsKPiArCXN0cnVjdCBjZG5fZHBfcG9ydCAq cG9ydDsKPiArCXN0cnVjdCBkcm1fZGV2aWNlICpkcm1fZGV2ID0gZGF0YTsKPiArCWludCByZXQs IGk7Cj4gKwo+ICsJcmV0ID0gY2RuX2RwX2luaXQoZHApOwo+ICsJaWYgKHJldCA8IDApCj4gKwkJ cmV0dXJuIHJldDsKPiArCj4gKwlkcC0+ZHJtX2RldiA9IGRybV9kZXY7Cj4gKwlkcC0+aHBkX3N0 YXR1cyA9IGNvbm5lY3Rvcl9zdGF0dXNfZGlzY29ubmVjdGVkOwo+ICsJZHAtPmZ3X3dhaXQgPSAx Owo+ICsKPiArCWVuY29kZXIgPSAmZHAtPmVuY29kZXI7Cj4gKwo+ICsJZW5jb2Rlci0+cG9zc2li bGVfY3J0Y3MgPSBkcm1fb2ZfZmluZF9wb3NzaWJsZV9jcnRjcyhkcm1fZGV2LAo+ICsJCQkJCQkJ ICAgICBkZXYtPm9mX25vZGUpOwo+ICsJRFJNX0RFQlVHX0tNUygicG9zc2libGVfY3J0Y3MgPSAw eCV4XG4iLCBlbmNvZGVyLT5wb3NzaWJsZV9jcnRjcyk7Cj4gKwo+ICsJcmV0ID0gZHJtX2VuY29k ZXJfaW5pdChkcm1fZGV2LCBlbmNvZGVyLCAmY2RuX2RwX2VuY29kZXJfZnVuY3MsCj4gKwkJCSAg ICAgICBEUk1fTU9ERV9FTkNPREVSX1RNRFMsIE5VTEwpOwo+ICsJaWYgKHJldCkgewo+ICsJCURS TV9FUlJPUigiZmFpbGVkIHRvIGluaXRpYWxpemUgZW5jb2RlciB3aXRoIGRybVxuIik7Cj4gKwkJ cmV0dXJuIHJldDsKPiArCX0KPiArCj4gKwlkcm1fZW5jb2Rlcl9oZWxwZXJfYWRkKGVuY29kZXIs ICZjZG5fZHBfZW5jb2Rlcl9oZWxwZXJfZnVuY3MpOwo+ICsKPiArCWNvbm5lY3RvciA9ICZkcC0+ Y29ubmVjdG9yOwo+ICsJY29ubmVjdG9yLT5wb2xsZWQgPSBEUk1fQ09OTkVDVE9SX1BPTExfSFBE Owo+ICsJY29ubmVjdG9yLT5kcG1zID0gRFJNX01PREVfRFBNU19PRkY7Cj4gKwo+ICsJcmV0ID0g ZHJtX2Nvbm5lY3Rvcl9pbml0KGRybV9kZXYsIGNvbm5lY3RvciwKPiArCQkJCSAmY2RuX2RwX2F0 b21pY19jb25uZWN0b3JfZnVuY3MsCj4gKwkJCQkgRFJNX01PREVfQ09OTkVDVE9SX0Rpc3BsYXlQ b3J0KTsKPiArCWlmIChyZXQpIHsKPiArCQlEUk1fRVJST1IoImZhaWxlZCB0byBpbml0aWFsaXpl IGNvbm5lY3RvciB3aXRoIGRybVxuIik7Cj4gKwkJZ290byBlcnJfZnJlZV9lbmNvZGVyOwo+ICsJ fQo+ICsKPiArCWRybV9jb25uZWN0b3JfaGVscGVyX2FkZChjb25uZWN0b3IsICZjZG5fZHBfY29u bmVjdG9yX2hlbHBlcl9mdW5jcyk7Cj4gKwo+ICsJcmV0ID0gZHJtX21vZGVfY29ubmVjdG9yX2F0 dGFjaF9lbmNvZGVyKGNvbm5lY3RvciwgZW5jb2Rlcik7Cj4gKwlpZiAocmV0KSB7Cj4gKwkJRFJN X0VSUk9SKCJmYWlsZWQgdG8gYXR0YWNoIGNvbm5lY3RvciBhbmQgZW5jb2RlclxuIik7Cj4gKwkJ Z290byBlcnJfZnJlZV9jb25uZWN0b3I7Cj4gKwl9Cj4gKwo+ICsJY2RuX2RwX2F1ZGlvX2NvZGVj X2luaXQoZHAsIGRldik7Cj4gKwo+ICsJZm9yIChpID0gMDsgaSA8IGRwLT5wb3J0czsgaSsrKSB7 Cj4gKwkJcG9ydCA9IGRwLT5wb3J0W2ldOwo+ICsKPiArCQlwb3J0LT5ldmVudF9uYi5ub3RpZmll cl9jYWxsID0gY2RuX2RwX3BkX2V2ZW50Owo+ICsJCUlOSVRfREVMQVlFRF9XT1JLKCZwb3J0LT5l dmVudF93cSwgY2RuX2RwX3BkX2V2ZW50X3dxKTsKPiArCQlyZXQgPSBleHRjb25fcmVnaXN0ZXJf bm90aWZpZXIocG9ydC0+ZXh0Y29uLCBFWFRDT05fRElTUF9EUCwKPiArCQkJCQkgICAgICAgJnBv cnQtPmV2ZW50X25iKTsKPiArCQlpZiAocmV0KSB7Cj4gKwkJCWRldl9lcnIoZGV2LCAicmVnaXN0 ZXIgRVhUQ09OX0RJU1BfRFAgbm90aWZpZXIgZXJyXG4iKTsKPiArCQkJcmV0dXJuIHJldDsKPiAr CQl9Cj4gKwo+ICsJCWlmIChleHRjb25fZ2V0X3N0YXRlKHBvcnQtPmV4dGNvbiwgRVhUQ09OX0RJ U1BfRFApKQo+ICsJCQlzY2hlZHVsZV9kZWxheWVkX3dvcmsoJnBvcnQtPmV2ZW50X3dxLCAwKTsK PiArCX0KPiArCj4gKwlyZXR1cm4gMDsKPiArCj4gK2Vycl9mcmVlX2Nvbm5lY3RvcjoKPiArCWRy bV9jb25uZWN0b3JfY2xlYW51cChjb25uZWN0b3IpOwo+ICtlcnJfZnJlZV9lbmNvZGVyOgo+ICsJ ZHJtX2VuY29kZXJfY2xlYW51cChlbmNvZGVyKTsKPiArCXJldHVybiByZXQ7Cj4gK30KPiArCj4g K3N0YXRpYyB2b2lkIGNkbl9kcF91bmJpbmQoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2 aWNlICptYXN0ZXIsIHZvaWQgKmRhdGEpCj4gK3sKPiArCXN0cnVjdCBjZG5fZHBfZGV2aWNlICpk cCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOwo+ICsJc3RydWN0IGRybV9lbmNvZGVyICplbmNvZGVy ID0gJmRwLT5lbmNvZGVyOwo+ICsJc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvciA9ICZk cC0+Y29ubmVjdG9yOwo+ICsJc3RydWN0IGNkbl9kcF9wb3J0ICpwb3J0Owo+ICsJaW50IGk7Cj4g Kwo+ICsJcGxhdGZvcm1fZGV2aWNlX3VucmVnaXN0ZXIoZHAtPmF1ZGlvX3BkZXYpOwo+ICsJY2Ru X2RwX2VuY29kZXJfZGlzYWJsZShlbmNvZGVyKTsKPiArCWVuY29kZXItPmZ1bmNzLT5kZXN0cm95 KGVuY29kZXIpOwo+ICsJY29ubmVjdG9yLT5mdW5jcy0+ZGVzdHJveShjb25uZWN0b3IpOwo+ICsK PiArCWZvciAoaSA9IDA7IGkgPCBkcC0+cG9ydHM7IGkrKykgewo+ICsJCXBvcnQgPSBkcC0+cG9y dFtpXTsKPiArCQlleHRjb25fdW5yZWdpc3Rlcl9ub3RpZmllcihwb3J0LT5leHRjb24sIEVYVENP Tl9ESVNQX0RQLAo+ICsJCQkJCSAgICZwb3J0LT5ldmVudF9uYik7Cj4gKwl9Cj4gK30KPiArCj4g K3N0YXRpYyBjb25zdCBzdHJ1Y3QgY29tcG9uZW50X29wcyBjZG5fZHBfY29tcG9uZW50X29wcyA9 IHsKPiArCS5iaW5kID0gY2RuX2RwX2JpbmQsCj4gKwkudW5iaW5kID0gY2RuX2RwX3VuYmluZCwK PiArfTsKPiArCj4gK3N0YXRpYyBpbnQgY2RuX2RwX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZp Y2UgKnBkZXYpCj4gK3sKPiArCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZwZGV2LT5kZXY7Cj4gKwlj b25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkICptYXRjaDsKPiArCXN0cnVjdCBjZG5fZHBfZGF0YSAq ZHBfZGF0YTsKPiArCXN0cnVjdCBjZG5fZHBfcG9ydCAqcG9ydDsKPiArCXN0cnVjdCBjZG5fZHBf ZGV2aWNlICpkcDsKPiArCXN0cnVjdCBleHRjb25fZGV2ICpleHRjb247Cj4gKwlzdHJ1Y3QgcGh5 ICpwaHk7Cj4gKwlpbnQgaTsKPiArCj4gKwlkcCA9IGRldm1fa3phbGxvYyhkZXYsIHNpemVvZigq ZHApLCBHRlBfS0VSTkVMKTsKPiArCWlmICghZHApCj4gKwkJcmV0dXJuIC1FTk9NRU07Cj4gKwlk cC0+ZGV2ID0gZGV2Owo+ICsKPiArCW1hdGNoID0gb2ZfbWF0Y2hfbm9kZShjZG5fZHBfZHRfaWRz LCBwZGV2LT5kZXYub2Zfbm9kZSk7Cj4gKwlkcF9kYXRhID0gKHN0cnVjdCBjZG5fZHBfZGF0YSAq KW1hdGNoLT5kYXRhOwo+ICsKPiArCWZvciAoaSA9IDA7IGkgPCBkcF9kYXRhLT5tYXhfcGh5OyBp KyspIHsKPiArCQlleHRjb24gPSBleHRjb25fZ2V0X2VkZXZfYnlfcGhhbmRsZShkZXYsIGkpOwo+ ICsJCXBoeSA9IGRldm1fb2ZfcGh5X2dldF9ieV9pbmRleChkZXYsIGRldi0+b2Zfbm9kZSwgaSk7 Cj4gKwo+ICsJCWlmIChQVFJfRVJSKGV4dGNvbikgPT0gLUVQUk9CRV9ERUZFUiB8fAo+ICsJCSAg ICBQVFJfRVJSKHBoeSkgPT0gLUVQUk9CRV9ERUZFUikKPiArCQkJcmV0dXJuIC1FUFJPQkVfREVG RVI7Cj4gKwo+ICsJCWlmIChJU19FUlIoZXh0Y29uKSB8fCBJU19FUlIocGh5KSkKPiArCQkJY29u dGludWU7Cj4gKwo+ICsJCXBvcnQgPSBkZXZtX2t6YWxsb2MoZGV2LCBzaXplb2YoKnBvcnQpLCBH RlBfS0VSTkVMKTsKPiArCQlpZiAoIWRwKQo+ICsJCQlyZXR1cm4gLUVOT01FTTsKPiArCj4gKwkJ cG9ydC0+ZXh0Y29uID0gZXh0Y29uOwo+ICsJCXBvcnQtPnBoeSA9IHBoeTsKPiArCQlwb3J0LT5k cCA9IGRwOwo+ICsJCXBvcnQtPmlkID0gaTsKPiArCQlkcC0+cG9ydFtkcC0+cG9ydHMrK10gPSBw b3J0Owo+ICsJfQo+ICsKPiArCWlmICghZHAtPnBvcnRzKSB7Cj4gKwkJZGV2X2VycihkZXYsICJt aXNzaW5nIGV4dGNvbiBvciBwaHlcbiIpOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsJfQo+ICsK PiArCWRldl9zZXRfZHJ2ZGF0YShkZXYsIGRwKTsKPiArCj4gKwlyZXR1cm4gY29tcG9uZW50X2Fk ZChkZXYsICZjZG5fZHBfY29tcG9uZW50X29wcyk7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgY2Ru X2RwX3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQo+ICt7Cj4gKwljb21wb25l bnRfZGVsKCZwZGV2LT5kZXYsICZjZG5fZHBfY29tcG9uZW50X29wcyk7Cj4gKwo+ICsJcmV0dXJu IDA7Cj4gK30KPiArCj4gK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIGNkbl9kcF9kcml2 ZXIgPSB7Cj4gKwkucHJvYmUgPSBjZG5fZHBfcHJvYmUsCj4gKwkucmVtb3ZlID0gY2RuX2RwX3Jl bW92ZSwKPiArCS5kcml2ZXIgPSB7Cj4gKwkJICAgLm5hbWUgPSAiY2RuLWRwIiwKPiArCQkgICAu b3duZXIgPSBUSElTX01PRFVMRSwKPiArCQkgICAub2ZfbWF0Y2hfdGFibGUgPSBvZl9tYXRjaF9w dHIoY2RuX2RwX2R0X2lkcyksCj4gKwl9LAo+ICt9Owo+ICsKPiArbW9kdWxlX3BsYXRmb3JtX2Ry aXZlcihjZG5fZHBfZHJpdmVyKTsKPiArCj4gK01PRFVMRV9BVVRIT1IoIkNocmlzIFpob25nIDx6 eXdAcm9jay1jaGlwcy5jb20+Iik7Cj4gK01PRFVMRV9ERVNDUklQVElPTigiY2RuIERQIERyaXZl ciIpOwo+ICtNT0RVTEVfTElDRU5TRSgiR1BMIHYyIik7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2RybS9yb2NrY2hpcC9jZG4tZHAtY29yZS5oIGIvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlw L2Nkbi1kcC1jb3JlLmgKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAuLjBj ZjIzZGIKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL2Nk bi1kcC1jb3JlLmgKPiBAQCAtMCwwICsxLDEwNCBAQAo+ICsvKgo+ICsgKiBDb3B5cmlnaHQgKEMp IDIwMTYgQ2hyaXMgWmhvbmcgPHp5d0Byb2NrLWNoaXBzLmNvbT4KPiArICogQ29weXJpZ2h0IChD KSAyMDE2IFJPQ0tDSElQLCBJbmMuCj4gKyAqCj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNv ZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Cj4gKyAqIGl0IHVu ZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlz aGVkIGJ5Cj4gKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9u IDIgb2YgdGhlIExpY2Vuc2UuCj4gKyAqCj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRl ZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAo+ICsgKiBidXQgV0lUSE9VVCBB TlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgo+ICsgKiBN RVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUg dGhlCj4gKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCj4g KyAqLwo+ICsKPiArI2lmbmRlZiBfQ0ROX0RQX0NPUkVfSAo+ICsjZGVmaW5lIF9DRE5fRFBfQ09S RV9ICj4gKwo+ICsjaW5jbHVkZSA8ZHJtL2RybVAuaD4KPiArI2luY2x1ZGUgPGRybS9kcm1fY3J0 Y19oZWxwZXIuaD4KPiArI2luY2x1ZGUgPGRybS9kcm1fZHBfaGVscGVyLmg+Cj4gKyNpbmNsdWRl IDxkcm0vZHJtX3BhbmVsLmg+Cj4gKyNpbmNsdWRlICJyb2NrY2hpcF9kcm1fZHJ2LmgiCj4gKwo+ ICsjZGVmaW5lIE1BWF9QSFkJCTIKPiArCj4gK2VudW0gYXVkaW9fZm9ybWF0IHsKPiArCUFGTVRf STJTID0gMCwKPiArCUFGTVRfU1BESUYgPSAxLAo+ICsJQUZNVF9VTlVTRUQsCj4gK307Cj4gKwo+ ICtzdHJ1Y3QgYXVkaW9faW5mbyB7Cj4gKwllbnVtIGF1ZGlvX2Zvcm1hdCBmb3JtYXQ7Cj4gKwlp bnQgc2FtcGxlX3JhdGU7Cj4gKwlpbnQgY2hhbm5lbHM7Cj4gKwlpbnQgc2FtcGxlX3dpZHRoOwo+ ICt9Owo+ICsKPiArZW51bSB2aWNfcHhsX2VuY29kaW5nX2Zvcm1hdCB7Cj4gKwlQWExfUkdCID0g MHgxLAo+ICsJWUNCQ1JfNF80XzQgPSAweDIsCj4gKwlZQ0JDUl80XzJfMiA9IDB4NCwKPiArCVlD QkNSXzRfMl8wID0gMHg4LAo+ICsJWV9PTkxZID0gMHgxMCwKPiArfTsKPiArCj4gK3N0cnVjdCB2 aWRlb19pbmZvIHsKPiArCWJvb2wgaF9zeW5jX3BvbGFyaXR5Owo+ICsJYm9vbCB2X3N5bmNfcG9s YXJpdHk7Cj4gKwlib29sIGludGVybGFjZWQ7Cj4gKwlpbnQgY29sb3JfZGVwdGg7Cj4gKwllbnVt IHZpY19weGxfZW5jb2RpbmdfZm9ybWF0IGNvbG9yX2ZtdDsKPiArfTsKPiArCj4gK3N0cnVjdCBj ZG5fZmlybXdhcmVfaGVhZGVyIHsKPiArCXUzMiBzaXplX2J5dGVzOyAvKiBzaXplIG9mIHRoZSBl bnRpcmUgaGVhZGVyK2ltYWdlKHMpIGluIGJ5dGVzICovCj4gKwl1MzIgaGVhZGVyX3NpemU7IC8q IHNpemUgb2YganVzdCB0aGUgaGVhZGVyIGluIGJ5dGVzICovCj4gKwl1MzIgaXJhbV9zaXplOyAv KiBzaXplIG9mIGlyYW0gKi8KPiArCXUzMiBkcmFtX3NpemU7IC8qIHNpemUgb2YgZHJhbSAqLwo+ ICt9Owo+ICsKPiArc3RydWN0IGNkbl9kcF9wb3J0IHsKPiArCXN0cnVjdCBjZG5fZHBfZGV2aWNl ICpkcDsKPiArCXN0cnVjdCBub3RpZmllcl9ibG9jayBldmVudF9uYjsKPiArCXN0cnVjdCBkZWxh eWVkX3dvcmsgZXZlbnRfd3E7Cj4gKwlzdHJ1Y3QgZXh0Y29uX2RldiAqZXh0Y29uOwo+ICsJc3Ry dWN0IHBoeSAqcGh5Owo+ICsJdTggY2FwX2xhbmVzOwo+ICsJYm9vbCBwaHlfc3RhdHVzOwo+ICsJ dTggaWQ7Cj4gK307Cj4gKwo+ICtzdHJ1Y3QgY2RuX2RwX2RldmljZSB7Cj4gKwlzdHJ1Y3QgZGV2 aWNlICpkZXY7Cj4gKwlzdHJ1Y3QgZHJtX2RldmljZSAqZHJtX2RldjsKPiArCXN0cnVjdCBkcm1f Y29ubmVjdG9yIGNvbm5lY3RvcjsKPiArCXN0cnVjdCBkcm1fZW5jb2RlciBlbmNvZGVyOwo+ICsJ c3RydWN0IGRybV9kaXNwbGF5X21vZGUgbW9kZTsKPiArCXN0cnVjdCBwbGF0Zm9ybV9kZXZpY2Ug KmF1ZGlvX3BkZXY7Cj4gKwo+ICsJY29uc3Qgc3RydWN0IGZpcm13YXJlICpmdzsJLyogY2RuIGRw IGZpcm13YXJlICovCj4gKwl1bnNpZ25lZCBpbnQgZndfdmVyc2lvbjsJLyogY2RuIGZ3IHZlcnNp b24gKi8KPiArCXUzMiBmd193YWl0Owo+ICsJYm9vbCBmd19sb2FkZWQ7Cj4gKwlib29sIGZ3X2Fj dGl2ZWQ7Cj4gKwl2b2lkIF9faW9tZW0gKnJlZ3M7Cj4gKwlzdHJ1Y3QgcmVnbWFwICpncmY7Cj4g KwlzdHJ1Y3QgY2xrICpjb3JlX2NsazsKPiArCXN0cnVjdCBjbGsgKnBjbGs7Cj4gKwlzdHJ1Y3Qg Y2xrICpzcGRpZl9jbGs7Cj4gKwlzdHJ1Y3QgY2xrICpncmZfY2xrOwo+ICsJc3RydWN0IHJlc2V0 X2NvbnRyb2wgKnNwZGlmX3JzdDsKPiArCXN0cnVjdCBhdWRpb19pbmZvIGF1ZGlvX2luZm87Cj4g KwlzdHJ1Y3QgdmlkZW9faW5mbyB2aWRlb19pbmZvOwo+ICsJc3RydWN0IGRybV9kcF9saW5rIGxp bms7Cj4gKwlzdHJ1Y3QgY2RuX2RwX3BvcnQgKnBvcnRbTUFYX1BIWV07Cj4gKwl1OCBwb3J0czsK PiArCj4gKwl1OCBkcGNkW0RQX1JFQ0VJVkVSX0NBUF9TSVpFXTsKPiArCWVudW0gZHJtX2Nvbm5l Y3Rvcl9zdGF0dXMgaHBkX3N0YXR1czsKPiArCWludCBkcG1zX21vZGU7Cj4gKwlib29sIHNpbmtf aGFzX2F1ZGlvOwo+ICt9Owo+ICsjZW5kaWYgIC8qIF9DRE5fRFBfQ09SRV9IICovCj4gZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9jZG4tZHAtcmVnLmMgYi9kcml2ZXJzL2dw dS9kcm0vcm9ja2NoaXAvY2RuLWRwLXJlZy5jCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRl eCAwMDAwMDAwLi4yZWE3MDJkCj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9yb2NrY2hpcC9jZG4tZHAtcmVnLmMKPiBAQCAtMCwwICsxLDk1OSBAQAo+ICsvKgo+ICsgKiBD b3B5cmlnaHQgKEMpIEZ1emhvdSBSb2NrY2hpcCBFbGVjdHJvbmljcyBDby5MdGQKPiArICogQXV0 aG9yOiBDaHJpcyBaaG9uZyA8enl3QHJvY2stY2hpcHMuY29tPgo+ICsgKgo+ICsgKiBUaGlzIHNv ZnR3YXJlIGlzIGxpY2Vuc2VkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVi bGljCj4gKyAqIExpY2Vuc2UgdmVyc2lvbiAyLCBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29m dHdhcmUgRm91bmRhdGlvbiwgYW5kCj4gKyAqIG1heSBiZSBjb3BpZWQsIGRpc3RyaWJ1dGVkLCBh bmQgbW9kaWZpZWQgdW5kZXIgdGhvc2UgdGVybXMuCj4gKyAqCj4gKyAqIFRoaXMgcHJvZ3JhbSBp cyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAo+ICsgKiBi dXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50 eSBvZgo+ICsgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBV UlBPU0UuICBTZWUgdGhlCj4gKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3Jl IGRldGFpbHMuCj4gKyAqLwo+ICsKPiArI2luY2x1ZGUgPGxpbnV4L2Nsay5oPgo+ICsjaW5jbHVk ZSA8bGludXgvZGV2aWNlLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgo+ICsjaW5jbHVk ZSA8bGludXgvaW8uaD4KPiArI2luY2x1ZGUgPGxpbnV4L2lvcG9sbC5oPgo+ICsjaW5jbHVkZSA8 bGludXgvcmVzZXQuaD4KPiArCj4gKyNpbmNsdWRlICJjZG4tZHAtY29yZS5oIgo+ICsjaW5jbHVk ZSAiY2RuLWRwLXJlZy5oIgo+ICsKPiArI2RlZmluZSBDRE5fRFBfU1BESUZfQ0xLCQkyMDAwMDAw MDAKPiArI2RlZmluZSBGV19BTElWRV9USU1FT1VUX1VTCQkxMDAwMDAwCj4gKyNkZWZpbmUgTUFJ TEJPWF9SRVRSWV9VUwkJMTAwMAo+ICsjZGVmaW5lIE1BSUxCT1hfVElNRU9VVF9VUwkJNTAwMDAw MAo+ICsjZGVmaW5lIExJTktfVFJBSU5JTkdfUkVUUllfTVMJCTIwCj4gKyNkZWZpbmUgTElOS19U UkFJTklOR19USU1FT1VUX01TCTUwMAo+ICsKPiArdm9pZCBjZG5fZHBfc2V0X2Z3X2NsayhzdHJ1 Y3QgY2RuX2RwX2RldmljZSAqZHAsIHUzMiBjbGspCj4gK3sKPiArCXdyaXRlbChjbGsgLyAxMDAw MDAwLCBkcC0+cmVncyArIFNXX0NMS19IKTsKPiArfQo+ICsKPiArdm9pZCBjZG5fZHBfY2xvY2tf cmVzZXQoc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwKQo+ICt7Cj4gKwl1MzIgdmFsOwo+ICsKPiAr CXZhbCA9IERQVFhfRlJNUl9EQVRBX0NMS19SU1ROX0VOIHwKPiArCSAgICAgIERQVFhfRlJNUl9E QVRBX0NMS19FTiB8Cj4gKwkgICAgICBEUFRYX1BIWV9EQVRBX1JTVE5fRU4gfAo+ICsJICAgICAg RFBUWF9QSFlfREFUQV9DTEtfRU4gfAo+ICsJICAgICAgRFBUWF9QSFlfQ0hBUl9SU1ROX0VOIHwK PiArCSAgICAgIERQVFhfUEhZX0NIQVJfQ0xLX0VOIHwKPiArCSAgICAgIFNPVVJDRV9BVVhfU1lT X0NMS19SU1ROX0VOIHwKPiArCSAgICAgIFNPVVJDRV9BVVhfU1lTX0NMS19FTiB8Cj4gKwkgICAg ICBEUFRYX1NZU19DTEtfUlNUTl9FTiB8Cj4gKwkgICAgICBEUFRYX1NZU19DTEtfRU4gfAo+ICsJ ICAgICAgQ0ZHX0RQVFhfVklGX0NMS19SU1ROX0VOIHwKPiArCSAgICAgIENGR19EUFRYX1ZJRl9D TEtfRU47Cj4gKwl3cml0ZWwodmFsLCBkcC0+cmVncyArIFNPVVJDRV9EUFRYX0NBUik7Cj4gKwo+ ICsJdmFsID0gU09VUkNFX1BIWV9SU1ROX0VOIHwgU09VUkNFX1BIWV9DTEtfRU47Cj4gKwl3cml0 ZWwodmFsLCBkcC0+cmVncyArIFNPVVJDRV9QSFlfQ0FSKTsKPiArCj4gKwl2YWwgPSBTT1VSQ0Vf UEtUX1NZU19SU1ROX0VOIHwKPiArCSAgICAgIFNPVVJDRV9QS1RfU1lTX0NMS19FTiB8Cj4gKwkg ICAgICBTT1VSQ0VfUEtUX0RBVEFfUlNUTl9FTiB8Cj4gKwkgICAgICBTT1VSQ0VfUEtUX0RBVEFf Q0xLX0VOOwo+ICsJd3JpdGVsKHZhbCwgZHAtPnJlZ3MgKyBTT1VSQ0VfUEtUX0NBUik7Cj4gKwo+ ICsJdmFsID0gU1BESUZfQ0RSX0NMS19SU1ROX0VOIHwKPiArCSAgICAgIFNQRElGX0NEUl9DTEtf RU4gfAo+ICsJICAgICAgU09VUkNFX0FJRl9TWVNfUlNUTl9FTiB8Cj4gKwkgICAgICBTT1VSQ0Vf QUlGX1NZU19DTEtfRU4gfAo+ICsJICAgICAgU09VUkNFX0FJRl9DTEtfUlNUTl9FTiB8Cj4gKwkg ICAgICBTT1VSQ0VfQUlGX0NMS19FTjsKPiArCXdyaXRlbCh2YWwsIGRwLT5yZWdzICsgU09VUkNF X0FJRl9DQVIpOwo+ICsKPiArCXZhbCA9IFNPVVJDRV9DSVBIRVJfU1lTVEVNX0NMS19SU1ROX0VO IHwKPiArCSAgICAgIFNPVVJDRV9DSVBIRVJfU1lTX0NMS19FTiB8Cj4gKwkgICAgICBTT1VSQ0Vf Q0lQSEVSX0NIQVJfQ0xLX1JTVE5fRU4gfAo+ICsJICAgICAgU09VUkNFX0NJUEhFUl9DSEFSX0NM S19FTjsKPiArCXdyaXRlbCh2YWwsIGRwLT5yZWdzICsgU09VUkNFX0NJUEhFUl9DQVIpOwo+ICsK PiArCXZhbCA9IFNPVVJDRV9DUllQVE9fU1lTX0NMS19SU1ROX0VOIHwKPiArCSAgICAgIFNPVVJD RV9DUllQVE9fU1lTX0NMS19FTjsKPiArCXdyaXRlbCh2YWwsIGRwLT5yZWdzICsgU09VUkNFX0NS WVBUT19DQVIpOwo+ICsKPiArCXZhbCA9IH4oTUFJTEJPWF9JTlRfTUFTS19CSVQgfCBQSUZfSU5U X01BU0tfQklUKSAmIEFMTF9JTlRfTUFTSzsKPiArCXdyaXRlbCh2YWwsIGRwLT5yZWdzICsgQVBC X0lOVF9NQVNLKTsKPiArfQo+ICsKPiArc3RhdGljIGludCBjZG5fZHBfbWFpbGJveF9yZWFkKHN0 cnVjdCBjZG5fZHBfZGV2aWNlICpkcCwgYm9vbCBmb3JjZSkKPiArewo+ICsJaW50IHZhbCwgcmV0 Owo+ICsKPiArCWlmICghZHAtPmZ3X2FjdGl2ZWQgJiYgIWZvcmNlKQo+ICsJCXJldHVybiAtRVBF Uk07Cj4gKwo+ICsJcmV0ID0gcmVhZHhfcG9sbF90aW1lb3V0KHJlYWRsLCBkcC0+cmVncyArIE1B SUxCT1hfRU1QVFlfQUREUiwKPiArCQkJCSB2YWwsICF2YWwsIE1BSUxCT1hfUkVUUllfVVMsCj4g KwkJCQkgTUFJTEJPWF9USU1FT1VUX1VTKTsKPiArCWlmIChyZXQgPCAwKQo+ICsJCXJldHVybiBy ZXQ7Cj4gKwo+ICsJcmV0dXJuIHJlYWRsKGRwLT5yZWdzICsgTUFJTEJPWDBfUkRfREFUQSkgJiAw eGZmOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGNkcF9kcF9tYWlsYm94X3dyaXRlKHN0cnVjdCBj ZG5fZHBfZGV2aWNlICpkcCwgdTggdmFsLCBib29sIGZvcmNlKQo+ICt7Cj4gKwlpbnQgcmV0LCBm dWxsOwo+ICsKPiArCWlmICghZHAtPmZ3X2FjdGl2ZWQgJiYgIWZvcmNlKQo+ICsJCXJldHVybiAt RVBFUk07Cj4gKwo+ICsJcmV0ID0gcmVhZHhfcG9sbF90aW1lb3V0KHJlYWRsLCBkcC0+cmVncyAr IE1BSUxCT1hfRlVMTF9BRERSLAo+ICsJCQkJIGZ1bGwsICFmdWxsLCBNQUlMQk9YX1JFVFJZX1VT LAo+ICsJCQkJIE1BSUxCT1hfVElNRU9VVF9VUyk7Cj4gKwlpZiAocmV0IDwgMCkKPiArCQlyZXR1 cm4gcmV0Owo+ICsKPiArCXdyaXRlbCh2YWwsIGRwLT5yZWdzICsgTUFJTEJPWDBfV1JfREFUQSk7 Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgY2RuX2RwX21haWxib3hf dmFsaWRhdGVfcmVjZWl2ZShzdHJ1Y3QgY2RuX2RwX2RldmljZSAqZHAsCj4gKwkJCQkJICAgdTgg bW9kdWxlX2lkLCB1OCBvcGNvZGUsCj4gKwkJCQkJICAgdTggcmVxX3NpemUpCj4gK3sKPiArCXUz MiBtYm94X3NpemUsIGk7Cj4gKwl1OCBoZWFkZXJbNF07Cj4gKwlpbnQgcmV0Owo+ICsKPiArCS8q IHJlYWQgdGhlIGhlYWRlciBvZiB0aGUgbWVzc2FnZSAqLwo+ICsJZm9yIChpID0gMDsgaSA8IDQ7 IGkrKykgewo+ICsJCXJldCA9IGNkbl9kcF9tYWlsYm94X3JlYWQoZHAsIDApOwo+ICsJCWlmIChy ZXQgPCAwKQo+ICsJCQlyZXR1cm4gcmV0Owo+ICsKPiArCQloZWFkZXJbaV0gPSByZXQ7Cj4gKwl9 Cj4gKwo+ICsJbWJveF9zaXplID0gKGhlYWRlclsyXSA8PCA4KSB8IGhlYWRlclszXTsKPiArCj4g KwlpZiAob3Bjb2RlICE9IGhlYWRlclswXSB8fCBtb2R1bGVfaWQgIT0gaGVhZGVyWzFdIHx8Cj4g KwkgICAgcmVxX3NpemUgIT0gbWJveF9zaXplKSB7Cj4gKwkJLyoKPiArCQkgKiBJZiB0aGUgbWVz c2FnZSBpbiBtYWlsYm94IGlzIG5vdCB3aGF0IHdlIHdhbnQsIHdlIG5lZWQgdG8KPiArCQkgKiBj bGVhciB0aGUgbWFpbGJveCBieSByZWFkLgo+ICsJCSAqLwo+ICsJCWZvciAoaSA9IDA7IGkgPCBt Ym94X3NpemU7IGkrKykKPiArCQkJaWYgKGNkbl9kcF9tYWlsYm94X3JlYWQoZHAsIDApIDwgMCkK PiArCQkJCWJyZWFrOwo+ICsKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCX0KPiArCj4gKwlyZXR1 cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIGludCBjZG5fZHBfbWFpbGJveF9yZWFkX3JlY2VpdmUo c3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwLAo+ICsJCQkJICAgICAgIHU4ICpidWZmLCB1OCBidWZm X3NpemUpCj4gK3sKPiArCXUzMiBpOwo+ICsJaW50IHJldDsKPiArCj4gKwlmb3IgKGkgPSAwOyBp IDwgYnVmZl9zaXplOyBpKyspIHsKPiArCQlyZXQgPSBjZG5fZHBfbWFpbGJveF9yZWFkKGRwLCAw KTsKPiArCQlpZiAocmV0IDwgMCkKPiArCQkJcmV0dXJuIHJldDsKPiArCj4gKwkJYnVmZltpXSA9 IHJldDsKPiArCX0KPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIGludCBjZG5f ZHBfbWFpbGJveF9zZW5kKHN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCwgdTggbW9kdWxlX2lkLAo+ ICsJCQkgICAgICAgdTggb3Bjb2RlLCB1MTYgc2l6ZSwgdTggKm1lc3NhZ2UpCj4gK3sKPiArCXU4 IGhlYWRlcls0XTsKPiArCWludCByZXQsIGk7Cj4gKwo+ICsJaGVhZGVyWzBdID0gb3Bjb2RlOwo+ ICsJaGVhZGVyWzFdID0gbW9kdWxlX2lkOwo+ICsJaGVhZGVyWzJdID0gKHNpemUgPj4gOCkgJiAw eGZmOwo+ICsJaGVhZGVyWzNdID0gc2l6ZSAmIDB4ZmY7Cj4gKwo+ICsJZm9yIChpID0gMDsgaSA8 IDQ7IGkrKykgewo+ICsJCXJldCA9IGNkcF9kcF9tYWlsYm94X3dyaXRlKGRwLCBoZWFkZXJbaV0s IDApOwo+ICsJCWlmIChyZXQpCj4gKwkJCXJldHVybiByZXQ7Cj4gKwl9Cj4gKwo+ICsJZm9yIChp ID0gMDsgaSA8IHNpemU7IGkrKykgewo+ICsJCXJldCA9IGNkcF9kcF9tYWlsYm94X3dyaXRlKGRw LCBtZXNzYWdlW2ldLCAwKTsKPiArCQlpZiAocmV0KQo+ICsJCQlyZXR1cm4gcmV0Owo+ICsJfQo+ ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGNkbl9kcF9yZWdfd3JpdGUo c3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwLCB1MTYgYWRkciwgdTMyIHZhbCkKPiArewo+ICsJdTgg bXNnWzZdOwo+ICsKPiArCW1zZ1swXSA9IChhZGRyID4+IDgpICYgMHhmZjsKPiArCW1zZ1sxXSA9 IGFkZHIgJiAweGZmOwo+ICsJbXNnWzJdID0gKHZhbCA+PiAyNCkgJiAweGZmOwo+ICsJbXNnWzNd ID0gKHZhbCA+PiAxNikgJiAweGZmOwo+ICsJbXNnWzRdID0gKHZhbCA+PiA4KSAmIDB4ZmY7Cj4g Kwltc2dbNV0gPSB2YWwgJiAweGZmOwo+ICsJcmV0dXJuIGNkbl9kcF9tYWlsYm94X3NlbmQoZHAs IE1CX01PRFVMRV9JRF9EUF9UWCwgRFBUWF9XUklURV9SRUdJU1RFUiwKPiArCQkJCSAgIHNpemVv Zihtc2cpLCBtc2cpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGNkbl9kcF9yZWdfd3JpdGVfYml0 KHN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCwgdTE2IGFkZHIsCj4gKwkJCQl1OCBzdGFydF9iaXQs IHU4IGJpdHNfbm8sIHUzMiB2YWwpCj4gK3sKPiArCXU4IGZpZWxkWzhdOwo+ICsKPiArCWZpZWxk WzBdID0gKGFkZHIgPj4gOCkgJiAweGZmOwo+ICsJZmllbGRbMV0gPSBhZGRyICYgMHhmZjsKPiAr CWZpZWxkWzJdID0gc3RhcnRfYml0Owo+ICsJZmllbGRbM10gPSBiaXRzX25vOwo+ICsJZmllbGRb NF0gPSAodmFsID4+IDI0KSAmIDB4ZmY7Cj4gKwlmaWVsZFs1XSA9ICh2YWwgPj4gMTYpICYgMHhm ZjsKPiArCWZpZWxkWzZdID0gKHZhbCA+PiA4KSAmIDB4ZmY7Cj4gKwlmaWVsZFs3XSA9IHZhbCAm IDB4ZmY7Cj4gKwo+ICsJcmV0dXJuIGNkbl9kcF9tYWlsYm94X3NlbmQoZHAsIE1CX01PRFVMRV9J RF9EUF9UWCwgRFBUWF9XUklURV9GSUVMRCwKPiArCQkJCSAgIHNpemVvZihmaWVsZCksIGZpZWxk KTsKPiArfQo+ICsKPiAraW50IGNkbl9kcF9kcGNkX3JlYWQoc3RydWN0IGNkbl9kcF9kZXZpY2Ug KmRwLCB1MzIgYWRkciwgdTggKmRhdGEsIHUxNiBsZW4pCj4gK3sKPiArCXU4IG1zZ1s1XSwgcmVn WzVdOwo+ICsJaW50IHJldDsKPiArCj4gKwltc2dbMF0gPSAobGVuID4+IDgpICYgMHhmZjsKPiAr CW1zZ1sxXSA9IGxlbiAmIDB4ZmY7Cj4gKwltc2dbMl0gPSAoYWRkciA+PiAxNikgJiAweGZmOwo+ ICsJbXNnWzNdID0gKGFkZHIgPj4gOCkgJiAweGZmOwo+ICsJbXNnWzRdID0gYWRkciAmIDB4ZmY7 Cj4gKwlyZXQgPSBjZG5fZHBfbWFpbGJveF9zZW5kKGRwLCBNQl9NT0RVTEVfSURfRFBfVFgsIERQ VFhfUkVBRF9EUENELAo+ICsJCQkJICBzaXplb2YobXNnKSwgbXNnKTsKPiArCWlmIChyZXQpCj4g KwkJZ290byBlcnJfZHBjZF9yZWFkOwo+ICsKPiArCXJldCA9IGNkbl9kcF9tYWlsYm94X3ZhbGlk YXRlX3JlY2VpdmUoZHAsIE1CX01PRFVMRV9JRF9EUF9UWCwKPiArCQkJCQkgICAgICBEUFRYX1JF QURfRFBDRCwKPiArCQkJCQkgICAgICBzaXplb2YocmVnKSArIGxlbik7Cj4gKwlpZiAocmV0KQo+ ICsJCWdvdG8gZXJyX2RwY2RfcmVhZDsKPiArCj4gKwlyZXQgPSBjZG5fZHBfbWFpbGJveF9yZWFk X3JlY2VpdmUoZHAsIHJlZywgc2l6ZW9mKHJlZykpOwo+ICsJaWYgKHJldCkKPiArCQlnb3RvIGVy cl9kcGNkX3JlYWQ7Cj4gKwo+ICsJcmV0ID0gY2RuX2RwX21haWxib3hfcmVhZF9yZWNlaXZlKGRw LCBkYXRhLCBsZW4pOwo+ICsKPiArZXJyX2RwY2RfcmVhZDoKPiArCXJldHVybiByZXQ7Cj4gK30K PiArCj4gK2ludCBjZG5fZHBfZHBjZF93cml0ZShzdHJ1Y3QgY2RuX2RwX2RldmljZSAqZHAsIHUz MiBhZGRyLCB1OCB2YWx1ZSkKPiArewo+ICsJdTggbXNnWzZdLCByZWdbNV07Cj4gKwlpbnQgcmV0 Owo+ICsKPiArCW1zZ1swXSA9IDA7Cj4gKwltc2dbMV0gPSAxOwo+ICsJbXNnWzJdID0gKGFkZHIg Pj4gMTYpICYgMHhmZjsKPiArCW1zZ1szXSA9IChhZGRyID4+IDgpICYgMHhmZjsKPiArCW1zZ1s0 XSA9IGFkZHIgJiAweGZmOwo+ICsJbXNnWzVdID0gdmFsdWU7Cj4gKwlyZXQgPSBjZG5fZHBfbWFp bGJveF9zZW5kKGRwLCBNQl9NT0RVTEVfSURfRFBfVFgsIERQVFhfV1JJVEVfRFBDRCwKPiArCQkJ CSAgc2l6ZW9mKG1zZyksIG1zZyk7Cj4gKwlpZiAocmV0KQo+ICsJCWdvdG8gZXJyX2RwY2Rfd3Jp dGU7Cj4gKwo+ICsJcmV0ID0gY2RuX2RwX21haWxib3hfdmFsaWRhdGVfcmVjZWl2ZShkcCwgTUJf TU9EVUxFX0lEX0RQX1RYLAo+ICsJCQkJCSAgICAgIERQVFhfV1JJVEVfRFBDRCwgc2l6ZW9mKHJl ZykpOwo+ICsJaWYgKHJldCkKPiArCQlnb3RvIGVycl9kcGNkX3dyaXRlOwo+ICsKPiArCXJldCA9 IGNkbl9kcF9tYWlsYm94X3JlYWRfcmVjZWl2ZShkcCwgcmVnLCBzaXplb2YocmVnKSk7Cj4gKwlp ZiAocmV0KQo+ICsJCWdvdG8gZXJyX2RwY2Rfd3JpdGU7Cj4gKwo+ICsJaWYgKGFkZHIgIT0gKHJl Z1syXSA8PCAxNiB8IHJlZ1szXSA8PCA4IHwgcmVnWzRdKSkKPiArCQlyZXQgPSAtRUlOVkFMOwo+ ICsKPiArZXJyX2RwY2Rfd3JpdGU6Cj4gKwlpZiAocmV0KQo+ICsJCWRldl9lcnIoZHAtPmRldiwg ImRwY2Qgd3JpdGUgZmFpbGVkOiAlZFxuIiwgcmV0KTsKPiArCXJldHVybiByZXQ7Cj4gK30KPiAr Cj4gK2ludCBjZG5fZHBfbG9hZF9maXJtd2FyZShzdHJ1Y3QgY2RuX2RwX2RldmljZSAqZHAsIGNv bnN0IHUzMiAqaV9tZW0sCj4gKwkJCSB1MzIgaV9zaXplLCBjb25zdCB1MzIgKmRfbWVtLCB1MzIg ZF9zaXplKQo+ICt7Cj4gKwl1MzIgcmVnOwo+ICsJaW50IGksIHJldDsKPiArCj4gKwkvKiByZXNl dCB1Y3B1IGJlZm9yZSBsb2FkIGZpcm13YXJlKi8KPiArCXdyaXRlbChBUEJfSVJBTV9QQVRIIHwg QVBCX0RSQU1fUEFUSCB8IEFQQl9YVF9SRVNFVCwKPiArCSAgICAgICBkcC0+cmVncyArIEFQQl9D VFJMKTsKPiArCj4gKwlmb3IgKGkgPSAwOyBpIDwgaV9zaXplOyBpICs9IDQpCj4gKwkJd3JpdGVs KCppX21lbSsrLCBkcC0+cmVncyArIEFERFJfSU1FTSArIGkpOwo+ICsKPiArCWZvciAoaSA9IDA7 IGkgPCBkX3NpemU7IGkgKz0gNCkKPiArCQl3cml0ZWwoKmRfbWVtKyssIGRwLT5yZWdzICsgQURE Ul9ETUVNICsgaSk7Cj4gKwo+ICsJLyogdW4tcmVzZXQgdWNwdSAqLwo+ICsJd3JpdGVsKDAsIGRw LT5yZWdzICsgQVBCX0NUUkwpOwo+ICsKPiArCS8qIGNoZWNrIHRoZSBrZWVwIGFsaXZlIHJlZ2lz dGVyIHRvIG1ha2Ugc3VyZSBmdyB3b3JraW5nICovCj4gKwlyZXQgPSByZWFkeF9wb2xsX3RpbWVv dXQocmVhZGwsIGRwLT5yZWdzICsgS0VFUF9BTElWRSwKPiArCQkJCSByZWcsIHJlZywgMjAwMCwg RldfQUxJVkVfVElNRU9VVF9VUyk7Cj4gKwlpZiAocmV0IDwgMCkgewo+ICsJCWRldl9lcnIoZHAt PmRldiwgImZhaWxlZCB0byBsb2FkZWQgdGhlIEZXIHJlZyA9ICV4XG4iLCByZWcpOwo+ICsJCXJl dHVybiAtRUlOVkFMOwo+ICsJfQo+ICsKPiArCXJlZyA9IHJlYWRsKGRwLT5yZWdzICsgVkVSX0wp ICYgMHhmZjsKPiArCWRwLT5md192ZXJzaW9uID0gcmVnOwo+ICsJcmVnID0gcmVhZGwoZHAtPnJl Z3MgKyBWRVJfSCkgJiAweGZmOwo+ICsJZHAtPmZ3X3ZlcnNpb24gfD0gcmVnIDw8IDg7Cj4gKwly ZWcgPSByZWFkbChkcC0+cmVncyArIFZFUl9MSUJfTF9BRERSKSAmIDB4ZmY7Cj4gKwlkcC0+Zndf dmVyc2lvbiB8PSByZWcgPDwgMTY7Cj4gKwlyZWcgPSByZWFkbChkcC0+cmVncyArIFZFUl9MSUJf SF9BRERSKSAmIDB4ZmY7Cj4gKwlkcC0+ZndfdmVyc2lvbiB8PSByZWcgPDwgMjQ7Cj4gKwo+ICsJ ZGV2X2RiZyhkcC0+ZGV2LCAiZmlybXdhcmUgdmVyc2lvbjogJXhcbiIsIGRwLT5md192ZXJzaW9u KTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiAraW50IGNkbl9kcF9zZXRfZmlybXdhcmVf YWN0aXZlKHN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCwgYm9vbCBlbmFibGUpCj4gK3sKPiArCXU4 IG1zZ1s1XTsKPiArCWludCByZXQsIGk7Cj4gKwo+ICsJbXNnWzBdID0gR0VORVJBTF9NQUlOX0NP TlRST0w7Cj4gKwltc2dbMV0gPSBNQl9NT0RVTEVfSURfR0VORVJBTDsKPiArCW1zZ1syXSA9IDA7 Cj4gKwltc2dbM10gPSAxOwo+ICsJbXNnWzRdID0gZW5hYmxlID8gRldfQUNUSVZFIDogRldfU1RB TkRCWTsKPiArCj4gKwlmb3IgKGkgPSAwOyBpIDwgc2l6ZW9mKG1zZyk7IGkrKykgewo+ICsJCXJl dCA9IGNkcF9kcF9tYWlsYm94X3dyaXRlKGRwLCBtc2dbaV0sIDEpOwo+ICsJCWlmIChyZXQpCj4g KwkJCWdvdG8gZXJyX3NldF9maXJtd2FyZV9hY3RpdmU7Cj4gKwl9Cj4gKwo+ICsJLyogcmVhZCB0 aGUgZmlybXdhcmUgc3RhdGUgKi8KPiArCWZvciAoaSA9IDA7IGkgPCBzaXplb2YobXNnKTsgaSsr KSAgewo+ICsJCXJldCA9IGNkbl9kcF9tYWlsYm94X3JlYWQoZHAsIDEpOwo+ICsJCWlmIChyZXQg PCAwKQo+ICsJCQlnb3RvIGVycl9zZXRfZmlybXdhcmVfYWN0aXZlOwo+ICsKPiArCQltc2dbaV0g PSByZXQ7Cj4gKwl9Cj4gKwo+ICsJZHAtPmZ3X2FjdGl2ZWQgPSAobXNnWzRdID09IEZXX0FDVElW RSk7Cj4gKwlyZXQgPSAwOwo+ICsKPiArZXJyX3NldF9maXJtd2FyZV9hY3RpdmU6Cj4gKwlpZiAo cmV0IDwgMCkKPiArCQlkZXZfZXJyKGRwLT5kZXYsICJzZXQgZmlybXdhcmUgYWN0aXZlIGZhaWxl ZFxuIik7Cj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtpbnQgY2RuX2RwX3NldF9ob3N0X2Nh cChzdHJ1Y3QgY2RuX2RwX2RldmljZSAqZHAsIHU4IGxhbmVzLCBib29sIGZsaXApCj4gK3sKPiAr CXU4IG1zZ1s4XTsKPiArCWludCByZXQ7Cj4gKwo+ICsJbXNnWzBdID0gQ0ROX0RQX01BWF9MSU5L X1JBVEU7Cj4gKwltc2dbMV0gPSBsYW5lczsKPiArCW1zZ1syXSA9IFZPTFRBR0VfTEVWRUxfMjsK PiArCW1zZ1szXSA9IFBSRV9FTVBIQVNJU19MRVZFTF8zOwo+ICsJbXNnWzRdID0gUFRTMSB8IFBU UzIgfCBQVFMzIHwgUFRTNDsKPiArCW1zZ1s1XSA9IEZBU1RfTFRfTk9UX1NVUFBPUlQ7Cj4gKwlt c2dbNl0gPSBmbGlwID8gTEFORV9NQVBQSU5HX0ZMSVBQRUQgOiBMQU5FX01BUFBJTkdfTk9STUFM Owo+ICsJbXNnWzddID0gRU5IQU5DRUQ7Cj4gKwo+ICsJcmV0ID0gY2RuX2RwX21haWxib3hfc2Vu ZChkcCwgTUJfTU9EVUxFX0lEX0RQX1RYLAo+ICsJCQkJICBEUFRYX1NFVF9IT1NUX0NBUEFCSUxJ VElFUywKPiArCQkJCSAgc2l6ZW9mKG1zZyksIG1zZyk7Cj4gKwlpZiAocmV0KQo+ICsJCWdvdG8g ZXJyX3NldF9ob3N0X2NhcDsKPiArCj4gKwlyZXQgPSBjZG5fZHBfcmVnX3dyaXRlKGRwLCBEUF9B VVhfU1dBUF9JTlZFUlNJT05fQ09OVFJPTCwKPiArCQkJICAgICAgIEFVWF9IT1NUX0lOVkVSVCk7 Cj4gKwo+ICtlcnJfc2V0X2hvc3RfY2FwOgo+ICsJaWYgKHJldCkKPiArCQlkZXZfZXJyKGRwLT5k ZXYsICJzZXQgaG9zdCBjYXAgZmFpbGVkOiAlZFxuIiwgcmV0KTsKPiArCXJldHVybiByZXQ7Cj4g K30KPiArCj4gK2ludCBjZG5fZHBfZXZlbnRfY29uZmlnKHN0cnVjdCBjZG5fZHBfZGV2aWNlICpk cCkKPiArewo+ICsJdTggbXNnWzVdOwo+ICsJaW50IHJldDsKPiArCj4gKwltZW1zZXQobXNnLCAw LCBzaXplb2YobXNnKSk7Cj4gKwo+ICsJbXNnWzBdID0gRFBUWF9FVkVOVF9FTkFCTEVfSFBEIHwg RFBUWF9FVkVOVF9FTkFCTEVfVFJBSU5JTkc7Cj4gKwo+ICsJcmV0ID0gY2RuX2RwX21haWxib3hf c2VuZChkcCwgTUJfTU9EVUxFX0lEX0RQX1RYLCBEUFRYX0VOQUJMRV9FVkVOVCwKPiArCQkJCSAg c2l6ZW9mKG1zZyksIG1zZyk7Cj4gKwlpZiAocmV0KQo+ICsJCWRldl9lcnIoZHAtPmRldiwgInNl dCBldmVudCBjb25maWcgZmFpbGVkOiAlZFxuIiwgcmV0KTsKPiArCj4gKwlyZXR1cm4gcmV0Owo+ ICt9Cj4gKwo+ICt1MzIgY2RuX2RwX2dldF9ldmVudChzdHJ1Y3QgY2RuX2RwX2RldmljZSAqZHAp Cj4gK3sKPiArCXJldHVybiByZWFkbChkcC0+cmVncyArIFNXX0VWRU5UUzApOwo+ICt9Cj4gKwo+ ICtpbnQgY2RuX2RwX2dldF9ocGRfc3RhdHVzKHN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCkKPiAr ewo+ICsJdTggc3RhdHVzOwo+ICsJaW50IHJldDsKPiArCj4gKwlyZXQgPSBjZG5fZHBfbWFpbGJv eF9zZW5kKGRwLCBNQl9NT0RVTEVfSURfRFBfVFgsIERQVFhfSFBEX1NUQVRFLAo+ICsJCQkJICAw LCBOVUxMKTsKPiArCWlmIChyZXQpCj4gKwkJZ290byBlcnJfZ2V0X2hwZDsKPiArCj4gKwlyZXQg PSBjZG5fZHBfbWFpbGJveF92YWxpZGF0ZV9yZWNlaXZlKGRwLCBNQl9NT0RVTEVfSURfRFBfVFgs Cj4gKwkJCQkJICAgICAgRFBUWF9IUERfU1RBVEUsIHNpemVvZihzdGF0dXMpKTsKPiArCWlmIChy ZXQpCj4gKwkJZ290byBlcnJfZ2V0X2hwZDsKPiArCj4gKwlyZXQgPSBjZG5fZHBfbWFpbGJveF9y ZWFkX3JlY2VpdmUoZHAsICZzdGF0dXMsIHNpemVvZihzdGF0dXMpKTsKPiArCWlmIChyZXQpCj4g KwkJZ290byBlcnJfZ2V0X2hwZDsKPiArCj4gKwlyZXR1cm4gc3RhdHVzOwo+ICsKPiArZXJyX2dl dF9ocGQ6Cj4gKwlkZXZfZXJyKGRwLT5kZXYsICJnZXQgaHBkIHN0YXR1cyBmYWlsZWQ6ICVkXG4i LCByZXQpOwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiAraW50IGNkbl9kcF9nZXRfZWRpZF9i bG9jayh2b2lkICpkYXRhLCB1OCAqZWRpZCwKPiArCQkJICB1bnNpZ25lZCBpbnQgYmxvY2ssIHNp emVfdCBsZW5ndGgpCj4gK3sKPiArCXN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCA9IGRhdGE7Cj4g Kwl1OCBtc2dbMl0sIHJlZ1syXTsKPiArCWludCByZXQ7Cj4gKwo+ICsJbXNnWzBdID0gYmxvY2sg LyAyOwo+ICsJbXNnWzFdID0gYmxvY2sgJSAyOwo+ICsKPiArCXJldCA9IGNkbl9kcF9tYWlsYm94 X3NlbmQoZHAsIE1CX01PRFVMRV9JRF9EUF9UWCwgRFBUWF9HRVRfRURJRCwKPiArCQkJCSAgc2l6 ZW9mKG1zZyksIG1zZyk7Cj4gKwlpZiAocmV0KQo+ICsJCWdvdG8gZXJyX2dldF9lZGlkOwo+ICsK PiArCXJldCA9IGNkbl9kcF9tYWlsYm94X3ZhbGlkYXRlX3JlY2VpdmUoZHAsIE1CX01PRFVMRV9J RF9EUF9UWCwKPiArCQkJCQkgICAgICBEUFRYX0dFVF9FRElELAo+ICsJCQkJCSAgICAgIHNpemVv ZihyZWcpICsgbGVuZ3RoKTsKPiArCWlmIChyZXQpCj4gKwkJZ290byBlcnJfZ2V0X2VkaWQ7Cj4g Kwo+ICsJcmV0ID0gY2RuX2RwX21haWxib3hfcmVhZF9yZWNlaXZlKGRwLCByZWcsIHNpemVvZihy ZWcpKTsKPiArCWlmIChyZXQpCj4gKwkJZ290byBlcnJfZ2V0X2VkaWQ7Cj4gKwo+ICsJcmV0ID0g Y2RuX2RwX21haWxib3hfcmVhZF9yZWNlaXZlKGRwLCBlZGlkLCBsZW5ndGgpOwo+ICsJaWYgKHJl dCkKPiArCQlnb3RvIGVycl9nZXRfZWRpZDsKPiArCj4gKwlpZiAocmVnWzBdICE9IGxlbmd0aCB8 fCByZWdbMV0gIT0gYmxvY2sgLyAyKQo+ICsJCXJldCA9IC1FSU5WQUw7Cj4gKwo+ICtlcnJfZ2V0 X2VkaWQ6Cj4gKwlpZiAocmV0KQo+ICsJCWRldl9lcnIoZHAtPmRldiwgImdldCBibG9ja1slZF0g ZWRpZCBmYWlsZWQ6ICVkXG4iLCBibG9jaywgcmV0KTsKPiArCXJldHVybiByZXQ7Cj4gK30KPiAr Cj4gK2ludCBjZG5fZHBfdHJhaW5pbmdfc3RhcnQoc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwKQo+ ICt7Cj4gKwl1bnNpZ25lZCBsb25nIHRpbWVvdXQ7Cj4gKwl1OCBtc2csIGV2ZW50WzJdOwo+ICsJ aW50IHJldDsKPiArCj4gKwltc2cgPSBMSU5LX1RSQUlOSU5HX1JVTjsKPiArCj4gKwkvKiBzdGFy dCB0cmFpbmluZyAqLwo+ICsJcmV0ID0gY2RuX2RwX21haWxib3hfc2VuZChkcCwgTUJfTU9EVUxF X0lEX0RQX1RYLCBEUFRYX1RSQUlOSU5HX0NPTlRST0wsCj4gKwkJCQkgIHNpemVvZihtc2cpLCAm bXNnKTsKPiArCWlmIChyZXQpCj4gKwkJZ290byBlcnJfdHJhaW5pbmdfc3RhcnQ7Cj4gKwo+ICsJ dGltZW91dCA9IGppZmZpZXMgKyBtc2Vjc190b19qaWZmaWVzKExJTktfVFJBSU5JTkdfVElNRU9V VF9NUyk7Cj4gKwl3aGlsZSAodGltZV9iZWZvcmUoamlmZmllcywgdGltZW91dCkpIHsKPiArCQlt c2xlZXAoTElOS19UUkFJTklOR19SRVRSWV9NUyk7Cj4gKwkJcmV0ID0gY2RuX2RwX21haWxib3hf c2VuZChkcCwgTUJfTU9EVUxFX0lEX0RQX1RYLAo+ICsJCQkJCSAgRFBUWF9SRUFEX0VWRU5ULCAw LCBOVUxMKTsKPiArCQlpZiAocmV0KQo+ICsJCQlnb3RvIGVycl90cmFpbmluZ19zdGFydDsKPiAr Cj4gKwkJcmV0ID0gY2RuX2RwX21haWxib3hfdmFsaWRhdGVfcmVjZWl2ZShkcCwgTUJfTU9EVUxF X0lEX0RQX1RYLAo+ICsJCQkJCQkgICAgICBEUFRYX1JFQURfRVZFTlQsCj4gKwkJCQkJCSAgICAg IHNpemVvZihldmVudCkpOwo+ICsJCWlmIChyZXQpCj4gKwkJCWdvdG8gZXJyX3RyYWluaW5nX3N0 YXJ0Owo+ICsKPiArCQlyZXQgPSBjZG5fZHBfbWFpbGJveF9yZWFkX3JlY2VpdmUoZHAsIGV2ZW50 LCBzaXplb2YoZXZlbnQpKTsKPiArCQlpZiAocmV0KQo+ICsJCQlnb3RvIGVycl90cmFpbmluZ19z dGFydDsKPiArCj4gKwkJaWYgKGV2ZW50WzFdICYgRVFfUEhBU0VfRklOSVNIRUQpCj4gKwkJCXJl dHVybiAwOwo+ICsJfQo+ICsKPiArCXJldCA9IC1FVElNRURPVVQ7Cj4gKwo+ICtlcnJfdHJhaW5p bmdfc3RhcnQ6Cj4gKwlkZXZfZXJyKGRwLT5kZXYsICJ0cmFpbmluZyBmYWlsZWQ6ICVkXG4iLCBy ZXQpOwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiAraW50IGNkbl9kcF9nZXRfdHJhaW5pbmdf c3RhdHVzKHN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCkKPiArewo+ICsJdTggc3RhdHVzWzEwXTsK PiArCWludCByZXQ7Cj4gKwo+ICsJcmV0ID0gY2RuX2RwX21haWxib3hfc2VuZChkcCwgTUJfTU9E VUxFX0lEX0RQX1RYLCBEUFRYX1JFQURfTElOS19TVEFULAo+ICsJCQkJICAwLCBOVUxMKTsKPiAr CWlmIChyZXQpCj4gKwkJZ290byBlcnJfZ2V0X3RyYWluaW5nX3N0YXR1czsKPiArCj4gKwlyZXQg PSBjZG5fZHBfbWFpbGJveF92YWxpZGF0ZV9yZWNlaXZlKGRwLCBNQl9NT0RVTEVfSURfRFBfVFgs Cj4gKwkJCQkJICAgICAgRFBUWF9SRUFEX0xJTktfU1RBVCwKPiArCQkJCQkgICAgICBzaXplb2Yo c3RhdHVzKSk7Cj4gKwlpZiAocmV0KQo+ICsJCWdvdG8gZXJyX2dldF90cmFpbmluZ19zdGF0dXM7 Cj4gKwo+ICsJcmV0ID0gY2RuX2RwX21haWxib3hfcmVhZF9yZWNlaXZlKGRwLCBzdGF0dXMsIHNp emVvZihzdGF0dXMpKTsKPiArCWlmIChyZXQpCj4gKwkJZ290byBlcnJfZ2V0X3RyYWluaW5nX3N0 YXR1czsKPiArCj4gKwlkcC0+bGluay5yYXRlID0gc3RhdHVzWzBdOwo+ICsJZHAtPmxpbmsubnVt X2xhbmVzID0gc3RhdHVzWzFdOwo+ICsKPiArZXJyX2dldF90cmFpbmluZ19zdGF0dXM6Cj4gKwlp ZiAocmV0KQo+ICsJCWRldl9lcnIoZHAtPmRldiwgImdldCB0cmFpbmluZyBzdGF0dXMgZmFpbGVk OiAlZFxuIiwgcmV0KTsKPiArCXJldHVybiByZXQ7Cj4gK30KPiArCj4gK2ludCBjZG5fZHBfc2V0 X3ZpZGVvX3N0YXR1cyhzdHJ1Y3QgY2RuX2RwX2RldmljZSAqZHAsIGludCBhY3RpdmUpCj4gK3sK PiArCXU4IG1zZzsKPiArCWludCByZXQ7Cj4gKwo+ICsJbXNnID0gISFhY3RpdmU7Cj4gKwo+ICsJ cmV0ID0gY2RuX2RwX21haWxib3hfc2VuZChkcCwgTUJfTU9EVUxFX0lEX0RQX1RYLCBEUFRYX1NF VF9WSURFTywKPiArCQkJCSAgc2l6ZW9mKG1zZyksICZtc2cpOwo+ICsJaWYgKHJldCkKPiArCQlk ZXZfZXJyKGRwLT5kZXYsICJzZXQgdmlkZW8gc3RhdHVzIGZhaWxlZDogJWRcbiIsIHJldCk7Cj4g Kwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiArc3RhdGljIGludCBjZG5fZHBfZ2V0X21zYV9t aXNjKHN0cnVjdCB2aWRlb19pbmZvICp2aWRlbywKPiArCQkJICAgICAgIHN0cnVjdCBkcm1fZGlz cGxheV9tb2RlICptb2RlKQo+ICt7Cj4gKwl1MzIgbXNhX21pc2M7Cj4gKwl1OCB2YWxbMl07Cj4g Kwo+ICsJc3dpdGNoICh2aWRlby0+Y29sb3JfZm10KSB7Cj4gKwljYXNlIFBYTF9SR0I6Cj4gKwlj YXNlIFlfT05MWToKPiArCQl2YWxbMF0gPSAwOwo+ICsJCWJyZWFrOwo+ICsJLyogc2V0IFlVViBk ZWZhdWx0IGNvbG9yIHNwYWNlIGNvbnZlcnNpb24gdG8gQlQ2MDEgKi8KPiArCWNhc2UgWUNCQ1Jf NF80XzQ6Cj4gKwkJdmFsWzBdID0gNiArIEJUXzYwMSAqIDg7Cj4gKwkJYnJlYWs7Cj4gKwljYXNl IFlDQkNSXzRfMl8yOgo+ICsJCXZhbFswXSA9IDUgKyBCVF82MDEgKiA4Owo+ICsJCWJyZWFrOwo+ ICsJY2FzZSBZQ0JDUl80XzJfMDoKPiArCQl2YWxbMF0gPSA1Owo+ICsJCWJyZWFrOwo+ICsJfTsK PiArCj4gKwlzd2l0Y2ggKHZpZGVvLT5jb2xvcl9kZXB0aCkgewo+ICsJY2FzZSA2Ogo+ICsJCXZh bFsxXSA9IDA7Cj4gKwkJYnJlYWs7Cj4gKwljYXNlIDg6Cj4gKwkJdmFsWzFdID0gMTsKPiArCQli cmVhazsKPiArCWNhc2UgMTA6Cj4gKwkJdmFsWzFdID0gMjsKPiArCQlicmVhazsKPiArCWNhc2Ug MTI6Cj4gKwkJdmFsWzFdID0gMzsKPiArCQlicmVhazsKPiArCWNhc2UgMTY6Cj4gKwkJdmFsWzFd ID0gNDsKPiArCQlicmVhazsKPiArCX07Cj4gKwo+ICsJbXNhX21pc2MgPSAyICogdmFsWzBdICsg MzIgKiB2YWxbMV0gKwo+ICsJCSAgICgodmlkZW8tPmNvbG9yX2ZtdCA9PSBZX09OTFkpID8gKDEg PDwgMTQpIDogMCk7Cj4gKwo+ICsJcmV0dXJuIG1zYV9taXNjOwo+ICt9Cj4gKwo+ICtpbnQgY2Ru X2RwX2NvbmZpZ192aWRlbyhzdHJ1Y3QgY2RuX2RwX2RldmljZSAqZHApCj4gK3sKPiArCXN0cnVj dCB2aWRlb19pbmZvICp2aWRlbyA9ICZkcC0+dmlkZW9faW5mbzsKPiArCXN0cnVjdCBkcm1fZGlz cGxheV9tb2RlICptb2RlID0gJmRwLT5tb2RlOwo+ICsJdTY0IHN5bWJvbCwgdG1wOwo+ICsJdTMy IHZhbCwgbGlua19yYXRlOwo+ICsJdTggYml0X3Blcl9waXgsIHR1X3NpemVfcmVnID0gVFVfU0la RTsKPiArCWludCByZXQ7Cj4gKwo+ICsJYml0X3Blcl9waXggPSAodmlkZW8tPmNvbG9yX2ZtdCA9 PSBZQ0JDUl80XzJfMikgPwo+ICsJCSAgICAgICh2aWRlby0+Y29sb3JfZGVwdGggKiAyKSA6ICh2 aWRlby0+Y29sb3JfZGVwdGggKiAzKTsKPiArCj4gKwlsaW5rX3JhdGUgPSBkcm1fZHBfYndfY29k ZV90b19saW5rX3JhdGUoZHAtPmxpbmsucmF0ZSkgLyAxMDAwOwo+ICsKPiArCXZhbCA9IFZJRl9C WVBBU1NfSU5URVJMQUNFOwo+ICsJcmV0ID0gY2RuX2RwX3JlZ193cml0ZShkcCwgQk5EX0hTWU5D MlZTWU5DLCB2YWwpOwo+ICsJaWYgKHJldCkKPiArCQlnb3RvIGVycl9jb25maWdfdmlkZW87Cj4g Kwo+ICsJcmV0ID0gY2RuX2RwX3JlZ193cml0ZShkcCwgSFNZTkMyVlNZTkNfUE9MX0NUUkwsIDAp Owo+ICsJaWYgKHJldCkKPiArCQlnb3RvIGVycl9jb25maWdfdmlkZW87Cj4gKwo+ICsJLyoKPiAr CSAqIGdldCBhIGJlc3QgdHVfc2l6ZSBhbmQgdmFsaWQgc3ltYm9sOgo+ICsJICogMS4gY2hvc2Ug TGNsayBmcmVxKDE2Mk1oeiwgMjcwTWh6LCA1NDBNaHopLCBzZXQgVFUgdG8gMzIKPiArCSAqIDIu IGNhbGN1bGF0ZSBWUyh2YWxpZCBzeW1ib2wpID0gVFUgKiBQY2xrICogQnBwIC8gKExjbGsgKiBM YW5lcykKPiArCSAqIDMuIGlmIFZTID4gKi44NSBvciBWUyA8ICouMSBvciBWUyA8IDIgb3IgVFUg PCBWUyArIDQsIHRoZW4gc2V0Cj4gKwkgKiAgICBUVSArPSAyIGFuZCByZXBlYXQgMm5kIHN0ZXAu Cj4gKwkgKi8KPiArCWRvIHsKPiArCQl0dV9zaXplX3JlZyArPSAyOwo+ICsJCXRtcCA9IHR1X3Np emVfcmVnICogbW9kZS0+Y2xvY2sgKiBiaXRfcGVyX3BpeDsKPiArCQl0bXAgLz0gZHAtPmxpbmsu bnVtX2xhbmVzICogbGlua19yYXRlICogODsKPiArCQlzeW1ib2wgPSB0bXAgLyAxMDAwOwo+ICsJ fSB3aGlsZSAoKHN5bWJvbCA8PSAxKSB8fCAodHVfc2l6ZV9yZWcgLSBzeW1ib2wgPCA0KSB8fAo+ ICsJCSAodG1wICUgMTAwMCA+IDg1MCkgfHwgKHRtcCAlIDEwMDAgPCAxMDApKTsKPiArCj4gKwl2 YWwgPSBzeW1ib2wgKyAodHVfc2l6ZV9yZWcgPDwgOCk7Cj4gKwlyZXQgPSBjZG5fZHBfcmVnX3dy aXRlKGRwLCBEUF9GUkFNRVJfVFUsIHZhbCk7Cj4gKwlpZiAocmV0KQo+ICsJCWdvdG8gZXJyX2Nv bmZpZ192aWRlbzsKPiArCj4gKwkvKiBzZXQgdGhlIEZJRk8gQnVmZmVyIHNpemUgKi8KPiArCXZh bCA9ICgobW9kZS0+Y2xvY2sgKiAoc3ltYm9sICsgMSkgLyAxMDAwKSArIGxpbmtfcmF0ZSk7Cj4g Kwl2YWwgLz0gKGRwLT5saW5rLm51bV9sYW5lcyAqIGxpbmtfcmF0ZSk7Cj4gKwl2YWwgPSA4ICog KHN5bWJvbCArIDEpIC8gYml0X3Blcl9waXggLSB2YWw7Cj4gKwl2YWwgKz0gMjsKPiArCXJldCA9 IGNkbl9kcF9yZWdfd3JpdGUoZHAsIERQX1ZDX1RBQkxFKDE1KSwgdmFsKTsKPiArCj4gKwlzd2l0 Y2ggKHZpZGVvLT5jb2xvcl9kZXB0aCkgewo+ICsJY2FzZSA2Ogo+ICsJCXZhbCA9IEJDU182Owo+ ICsJCWJyZWFrOwo+ICsJY2FzZSA4Ogo+ICsJCXZhbCA9IEJDU184Owo+ICsJCWJyZWFrOwo+ICsJ Y2FzZSAxMDoKPiArCQl2YWwgPSBCQ1NfMTA7Cj4gKwkJYnJlYWs7Cj4gKwljYXNlIDEyOgo+ICsJ CXZhbCA9IEJDU18xMjsKPiArCQlicmVhazsKPiArCWNhc2UgMTY6Cj4gKwkJdmFsID0gQkNTXzE2 Owo+ICsJCWJyZWFrOwo+ICsJfTsKPiArCj4gKwl2YWwgKz0gdmlkZW8tPmNvbG9yX2ZtdCA8PCA4 Owo+ICsJcmV0ID0gY2RuX2RwX3JlZ193cml0ZShkcCwgRFBfRlJBTUVSX1BYTF9SRVBSLCB2YWwp Owo+ICsJaWYgKHJldCkKPiArCQlnb3RvIGVycl9jb25maWdfdmlkZW87Cj4gKwo+ICsJdmFsID0g dmlkZW8tPmhfc3luY19wb2xhcml0eSA/IERQX0ZSQU1FUl9TUF9IU1AgOiAwOwo+ICsJdmFsIHw9 IHZpZGVvLT52X3N5bmNfcG9sYXJpdHkgPyBEUF9GUkFNRVJfU1BfVlNQIDogMDsKPiArCXJldCA9 IGNkbl9kcF9yZWdfd3JpdGUoZHAsIERQX0ZSQU1FUl9TUCwgdmFsKTsKPiArCWlmIChyZXQpCj4g KwkJZ290byBlcnJfY29uZmlnX3ZpZGVvOwo+ICsKPiArCXZhbCA9IChtb2RlLT5oc3luY19zdGFy dCAtIG1vZGUtPmhkaXNwbGF5KSA8PCAxNjsKPiArCXZhbCB8PSBtb2RlLT5odG90YWwgLSBtb2Rl LT5oc3luY19lbmQ7Cj4gKwlyZXQgPSBjZG5fZHBfcmVnX3dyaXRlKGRwLCBEUF9GUk9OVF9CQUNL X1BPUkNILCB2YWwpOwo+ICsJaWYgKHJldCkKPiArCQlnb3RvIGVycl9jb25maWdfdmlkZW87Cj4g Kwo+ICsJdmFsID0gbW9kZS0+aGRpc3BsYXkgKiBiaXRfcGVyX3BpeCAvIDg7Cj4gKwlyZXQgPSBj ZG5fZHBfcmVnX3dyaXRlKGRwLCBEUF9CWVRFX0NPVU5ULCB2YWwpOwo+ICsJaWYgKHJldCkKPiAr CQlnb3RvIGVycl9jb25maWdfdmlkZW87Cj4gKwo+ICsJdmFsID0gbW9kZS0+aHRvdGFsIHwgKCht b2RlLT5odG90YWwgLSBtb2RlLT5oc3luY19zdGFydCkgPDwgMTYpOwo+ICsJcmV0ID0gY2RuX2Rw X3JlZ193cml0ZShkcCwgTVNBX0hPUklaT05UQUxfMCwgdmFsKTsKPiArCWlmIChyZXQpCj4gKwkJ Z290byBlcnJfY29uZmlnX3ZpZGVvOwo+ICsKPiArCXZhbCA9IG1vZGUtPmhzeW5jX2VuZCAtIG1v ZGUtPmhzeW5jX3N0YXJ0Owo+ICsJdmFsIHw9IChtb2RlLT5oZGlzcGxheSA8PCAxNikgfCAodmlk ZW8tPmhfc3luY19wb2xhcml0eSA8PCAxNSk7Cj4gKwlyZXQgPSBjZG5fZHBfcmVnX3dyaXRlKGRw LCBNU0FfSE9SSVpPTlRBTF8xLCB2YWwpOwo+ICsJaWYgKHJldCkKPiArCQlnb3RvIGVycl9jb25m aWdfdmlkZW87Cj4gKwo+ICsJdmFsID0gbW9kZS0+dnRvdGFsOwo+ICsJdmFsIHw9ICgobW9kZS0+ dnRvdGFsIC0gbW9kZS0+dnN5bmNfc3RhcnQpIDw8IDE2KTsKPiArCXJldCA9IGNkbl9kcF9yZWdf d3JpdGUoZHAsIE1TQV9WRVJUSUNBTF8wLCB2YWwpOwo+ICsJaWYgKHJldCkKPiArCQlnb3RvIGVy cl9jb25maWdfdmlkZW87Cj4gKwo+ICsJdmFsID0gbW9kZS0+dnN5bmNfZW5kIC0gbW9kZS0+dnN5 bmNfc3RhcnQ7Cj4gKwl2YWwgfD0gbW9kZS0+dmRpc3BsYXkgPDwgMTYgfCAodmlkZW8tPnZfc3lu Y19wb2xhcml0eSA8PCAxNSk7Cj4gKwlyZXQgPSBjZG5fZHBfcmVnX3dyaXRlKGRwLCBNU0FfVkVS VElDQUxfMSwgdmFsKTsKPiArCWlmIChyZXQpCj4gKwkJZ290byBlcnJfY29uZmlnX3ZpZGVvOwo+ ICsKPiArCXZhbCA9IGNkbl9kcF9nZXRfbXNhX21pc2ModmlkZW8sIG1vZGUpOwo+ICsJcmV0ID0g Y2RuX2RwX3JlZ193cml0ZShkcCwgTVNBX01JU0MsIHZhbCk7Cj4gKwlpZiAocmV0KQo+ICsJCWdv dG8gZXJyX2NvbmZpZ192aWRlbzsKPiArCj4gKwlyZXQgPSBjZG5fZHBfcmVnX3dyaXRlKGRwLCBT VFJFQU1fQ09ORklHLCAxKTsKPiArCWlmIChyZXQpCj4gKwkJZ290byBlcnJfY29uZmlnX3ZpZGVv Owo+ICsKPiArCXZhbCA9IG1vZGUtPmhzeW5jX2VuZCAtIG1vZGUtPmhzeW5jX3N0YXJ0Owo+ICsJ dmFsIHw9IChtb2RlLT5oZGlzcGxheSA8PCAxNik7Cj4gKwlyZXQgPSBjZG5fZHBfcmVnX3dyaXRl KGRwLCBEUF9IT1JJWk9OVEFMLCB2YWwpOwo+ICsJaWYgKHJldCkKPiArCQlnb3RvIGVycl9jb25m aWdfdmlkZW87Cj4gKwo+ICsJdmFsID0gbW9kZS0+dnRvdGFsOwo+ICsJdmFsIC09IChtb2RlLT52 dG90YWwgLSBtb2RlLT52ZGlzcGxheSk7Cj4gKwl2YWwgfD0gKG1vZGUtPnZ0b3RhbCAtIG1vZGUt PnZzeW5jX3N0YXJ0KSA8PCAxNjsKPiArCXJldCA9IGNkbl9kcF9yZWdfd3JpdGUoZHAsIERQX1ZF UlRJQ0FMXzAsIHZhbCk7Cj4gKwlpZiAocmV0KQo+ICsJCWdvdG8gZXJyX2NvbmZpZ192aWRlbzsK PiArCj4gKwl2YWwgPSBtb2RlLT52dG90YWw7Cj4gKwlyZXQgPSBjZG5fZHBfcmVnX3dyaXRlKGRw LCBEUF9WRVJUSUNBTF8xLCB2YWwpOwo+ICsJaWYgKHJldCkKPiArCQlnb3RvIGVycl9jb25maWdf dmlkZW87Cj4gKwo+ICsJdmFsID0gIDA7Cj4gKwlyZXQgPSBjZG5fZHBfcmVnX3dyaXRlX2JpdChk cCwgRFBfVkJfSUQsIDIsIDEsIHZhbCk7Cj4gKwo+ICtlcnJfY29uZmlnX3ZpZGVvOgo+ICsJaWYg KHJldCkKPiArCQlkZXZfZXJyKGRwLT5kZXYsICJjb25maWcgdmlkZW8gZmFpbGVkOiAlZFxuIiwg cmV0KTsKPiArCXJldHVybiByZXQ7Cj4gK30KPiArCj4gK2ludCBjZG5fZHBfYXVkaW9fc3RvcChz dHJ1Y3QgY2RuX2RwX2RldmljZSAqZHAsIHN0cnVjdCBhdWRpb19pbmZvICphdWRpbykKPiArewo+ ICsJdTMyIHZhbDsKPiArCWludCByZXQ7Cj4gKwo+ICsJcmV0ID0gY2RuX2RwX3JlZ193cml0ZShk cCwgQVVESU9fUEFDS19DT05UUk9MLCAwKTsKPiArCWlmIChyZXQpIHsKPiArCQlkZXZfZXJyKGRw LT5kZXYsICJhdWRpbyBzdG9wIGZhaWxlZDogJWRcbiIsIHJldCk7Cj4gKwkJcmV0dXJuIHJldDsK PiArCX0KPiArCj4gKwl2YWwgPSBTUERJRl9BVkdfU0VMIHwgU1BESUZfSklUVEVSX0JZUEFTUzsK PiArCXZhbCB8PSBTUERJRl9GSUZPX01JRF9SQU5HRSgweGUwKTsKPiArCXZhbCB8PSBTUERJRl9K SVRURVJfVEhSU0goMHhlMCk7Cj4gKwl2YWwgfD0gU1BESUZfSklUVEVSX0FWR19XSU4oNyk7Cj4g Kwl3cml0ZWwodmFsLCBkcC0+cmVncyArIFNQRElGX0NUUkxfQUREUik7Cj4gKwo+ICsJLyogY2xl YXJuIHRoZSBhdWRpbyBjb25maWcgYW5kIHJlc2V0ICovCj4gKwl3cml0ZWwoMCwgZHAtPnJlZ3Mg KyBBVURJT19TUkNfQ05UTCk7Cj4gKwl3cml0ZWwoMCwgZHAtPnJlZ3MgKyBBVURJT19TUkNfQ05G Ryk7Cj4gKwl3cml0ZWwoQVVESU9fU1dfUlNULCBkcC0+cmVncyArIEFVRElPX1NSQ19DTlRMKTsK PiArCXdyaXRlbCgwLCBkcC0+cmVncyArIEFVRElPX1NSQ19DTlRMKTsKPiArCj4gKwkvKiByZXNl dCBzbXBsMnBja3QgY29tcG9uZW50ICAqLwo+ICsJd3JpdGVsKDAsIGRwLT5yZWdzICsgU01QTDJQ S1RfQ05UTCk7Cj4gKwl3cml0ZWwoQVVESU9fU1dfUlNULCBkcC0+cmVncyArIFNNUEwyUEtUX0NO VEwpOwo+ICsJd3JpdGVsKDAsIGRwLT5yZWdzICsgU01QTDJQS1RfQ05UTCk7Cj4gKwo+ICsJLyog cmVzZXQgRklGTyAqLwo+ICsJd3JpdGVsKEFVRElPX1NXX1JTVCwgZHAtPnJlZ3MgKyBGSUZPX0NO VEwpOwo+ICsJd3JpdGVsKDAsIGRwLT5yZWdzICsgRklGT19DTlRMKTsKPiArCj4gKwlpZiAoYXVk aW8tPmZvcm1hdCA9PSBBRk1UX1NQRElGKQo+ICsJCWNsa19kaXNhYmxlX3VucHJlcGFyZShkcC0+ c3BkaWZfY2xrKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiAraW50IGNkbl9kcF9hdWRp b19tdXRlKHN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCwgYm9vbCBlbmFibGUpCj4gK3sKPiArCWlu dCByZXQ7Cj4gKwo+ICsJcmV0ID0gY2RuX2RwX3JlZ193cml0ZV9iaXQoZHAsIERQX1ZCX0lELCA0 LCAxLCBlbmFibGUpOwo+ICsJaWYgKHJldCkKPiArCQlkZXZfZXJyKGRwLT5kZXYsICJhdWRpbyBt dXRlIGZhaWxlZDogJWRcbiIsIHJldCk7Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiAr c3RhdGljIHZvaWQgY2RuX2RwX2F1ZGlvX2NvbmZpZ19pMnMoc3RydWN0IGNkbl9kcF9kZXZpY2Ug KmRwLAo+ICsJCQkJICAgIHN0cnVjdCBhdWRpb19pbmZvICphdWRpbykKPiArewo+ICsJaW50IHN1 Yl9wY2t0X251bSA9IDEsIGkyc19wb3J0X2VuX3ZhbCA9IDB4ZiwgaTsKPiArCXUzMiB2YWw7Cj4g Kwo+ICsJaWYgKGF1ZGlvLT5jaGFubmVscyA9PSAyKSB7Cj4gKwkJaWYgKGRwLT5saW5rLm51bV9s YW5lcyA9PSAxKQo+ICsJCQlzdWJfcGNrdF9udW0gPSAyOwo+ICsJCWVsc2UKPiArCQkJc3ViX3Bj a3RfbnVtID0gNDsKPiArCj4gKwkJaTJzX3BvcnRfZW5fdmFsID0gMTsKPiArCX0gZWxzZSBpZiAo YXVkaW8tPmNoYW5uZWxzID09IDQpIHsKPiArCQlpMnNfcG9ydF9lbl92YWwgPSAzOwo+ICsJfQo+ ICsKPiArCXdyaXRlbCgweDAsIGRwLT5yZWdzICsgU1BESUZfQ1RSTF9BRERSKTsKPiArCj4gKwl3 cml0ZWwoU1lOQ19XUl9UT19DSF9aRVJPLCBkcC0+cmVncyArIEZJRk9fQ05UTCk7Cj4gKwo+ICsJ dmFsID0gTUFYX05VTV9DSChhdWRpby0+Y2hhbm5lbHMpOwo+ICsJdmFsIHw9IE5VTV9PRl9JMlNf UE9SVFMoYXVkaW8tPmNoYW5uZWxzKTsKPiArCXZhbCB8PSBBVURJT19UWVBFX0xQQ007Cj4gKwl2 YWwgfD0gQ0ZHX1NVQl9QQ0tUX05VTShzdWJfcGNrdF9udW0pOwo+ICsJd3JpdGVsKHZhbCwgZHAt PnJlZ3MgKyBTTVBMMlBLVF9DTkZHKTsKPiArCj4gKwlpZiAoYXVkaW8tPnNhbXBsZV93aWR0aCA9 PSAxNikKPiArCQl2YWwgPSAwOwo+ICsJZWxzZSBpZiAoYXVkaW8tPnNhbXBsZV93aWR0aCA9PSAy NCkKPiArCQl2YWwgPSAxIDw8IDk7Cj4gKwllbHNlCj4gKwkJdmFsID0gMiA8PCA5Owo+ICsKPiAr CXZhbCB8PSBBVURJT19DSF9OVU0oYXVkaW8tPmNoYW5uZWxzKTsKPiArCXZhbCB8PSBJMlNfREVD X1BPUlRfRU4oaTJzX3BvcnRfZW5fdmFsKTsKPiArCXZhbCB8PSBUUkFOU19TTVBMX1dJRFRIXzMy Owo+ICsJd3JpdGVsKHZhbCwgZHAtPnJlZ3MgKyBBVURJT19TUkNfQ05GRyk7Cj4gKwo+ICsJZm9y IChpID0gMDsgaSA8IChhdWRpby0+Y2hhbm5lbHMgKyAxKSAvIDI7IGkrKykgewo+ICsJCWlmIChh dWRpby0+c2FtcGxlX3dpZHRoID09IDE2KQo+ICsJCQl2YWwgPSAoMHgwOCA8PCA4KSB8ICgweDA4 IDw8IDIwKTsKPiArCQllbHNlIGlmIChhdWRpby0+c2FtcGxlX3dpZHRoID09IDI0KQo+ICsJCQl2 YWwgPSAoMHgwYiA8PCA4KSB8ICgweDBiIDw8IDIwKTsKPiArCj4gKwkJdmFsIHw9ICgoMiAqIGkp IDw8IDQpIHwgKCgyICogaSArIDEpIDw8IDE2KTsKPiArCQl3cml0ZWwodmFsLCBkcC0+cmVncyAr IFNUVFNfQklUX0NIKGkpKTsKPiArCX0KPiArCj4gKwlzd2l0Y2ggKGF1ZGlvLT5zYW1wbGVfcmF0 ZSkgewo+ICsJY2FzZSAzMjAwMDoKPiArCQl2YWwgPSBTQU1QTElOR19GUkVRKDMpIHwKPiArCQkg ICAgICBPUklHSU5BTF9TQU1QX0ZSRVEoMHhjKTsKPiArCQlicmVhazsKPiArCWNhc2UgNDQxMDA6 Cj4gKwkJdmFsID0gU0FNUExJTkdfRlJFUSgwKSB8Cj4gKwkJICAgICAgT1JJR0lOQUxfU0FNUF9G UkVRKDB4Zik7Cj4gKwkJYnJlYWs7Cj4gKwljYXNlIDQ4MDAwOgo+ICsJCXZhbCA9IFNBTVBMSU5H X0ZSRVEoMikgfAo+ICsJCSAgICAgIE9SSUdJTkFMX1NBTVBfRlJFUSgweGQpOwo+ICsJCWJyZWFr Owo+ICsJY2FzZSA4ODIwMDoKPiArCQl2YWwgPSBTQU1QTElOR19GUkVRKDgpIHwKPiArCQkgICAg ICBPUklHSU5BTF9TQU1QX0ZSRVEoMHg3KTsKPiArCQlicmVhazsKPiArCWNhc2UgOTYwMDA6Cj4g KwkJdmFsID0gU0FNUExJTkdfRlJFUSgweGEpIHwKPiArCQkgICAgICBPUklHSU5BTF9TQU1QX0ZS RVEoNSk7Cj4gKwkJYnJlYWs7Cj4gKwljYXNlIDE3NjQwMDoKPiArCQl2YWwgPSBTQU1QTElOR19G UkVRKDB4YykgfAo+ICsJCSAgICAgIE9SSUdJTkFMX1NBTVBfRlJFUSgzKTsKPiArCQlicmVhazsK PiArCWNhc2UgMTkyMDAwOgo+ICsJCXZhbCA9IFNBTVBMSU5HX0ZSRVEoMHhlKSB8Cj4gKwkJICAg ICAgT1JJR0lOQUxfU0FNUF9GUkVRKDEpOwo+ICsJCWJyZWFrOwo+ICsJfQo+ICsJdmFsIHw9IDQ7 Cj4gKwl3cml0ZWwodmFsLCBkcC0+cmVncyArIENPTV9DSF9TVFRTX0JJVFMpOwo+ICsKPiArCXdy aXRlbChTTVBMMlBLVF9FTiwgZHAtPnJlZ3MgKyBTTVBMMlBLVF9DTlRMKTsKPiArCXdyaXRlbChJ MlNfREVDX1NUQVJULCBkcC0+cmVncyArIEFVRElPX1NSQ19DTlRMKTsKPiArfQo+ICsKPiArc3Rh dGljIHZvaWQgY2RuX2RwX2F1ZGlvX2NvbmZpZ19zcGRpZihzdHJ1Y3QgY2RuX2RwX2RldmljZSAq ZHApCj4gK3sKPiArCXUzMiB2YWw7Cj4gKwo+ICsJdmFsID0gU1BESUZfQVZHX1NFTCB8IFNQRElG X0pJVFRFUl9CWVBBU1M7Cj4gKwl2YWwgfD0gU1BESUZfRklGT19NSURfUkFOR0UoMHhlMCk7Cj4g Kwl2YWwgfD0gU1BESUZfSklUVEVSX1RIUlNIKDB4ZTApOwo+ICsJdmFsIHw9IFNQRElGX0pJVFRF Ul9BVkdfV0lOKDcpOwo+ICsJd3JpdGVsKHZhbCwgZHAtPnJlZ3MgKyBTUERJRl9DVFJMX0FERFIp Owo+ICsKPiArCXdyaXRlbChTWU5DX1dSX1RPX0NIX1pFUk8sIGRwLT5yZWdzICsgRklGT19DTlRM KTsKPiArCj4gKwl2YWwgPSBNQVhfTlVNX0NIKDIpIHwgQVVESU9fVFlQRV9MUENNIHwgQ0ZHX1NV Ql9QQ0tUX05VTSg0KTsKPiArCXdyaXRlbCh2YWwsIGRwLT5yZWdzICsgU01QTDJQS1RfQ05GRyk7 Cj4gKwl3cml0ZWwoU01QTDJQS1RfRU4sIGRwLT5yZWdzICsgU01QTDJQS1RfQ05UTCk7Cj4gKwo+ ICsJdmFsID0gU1BESUZfRU5BQkxFIHwgU1BESUZfQVZHX1NFTCB8IFNQRElGX0pJVFRFUl9CWVBB U1M7Cj4gKwl2YWwgfD0gU1BESUZfRklGT19NSURfUkFOR0UoMHhlMCk7Cj4gKwl2YWwgfD0gU1BE SUZfSklUVEVSX1RIUlNIKDB4ZTApOwo+ICsJdmFsIHw9IFNQRElGX0pJVFRFUl9BVkdfV0lOKDcp Owo+ICsJd3JpdGVsKHZhbCwgZHAtPnJlZ3MgKyBTUERJRl9DVFJMX0FERFIpOwo+ICsKPiArCWNs a19wcmVwYXJlX2VuYWJsZShkcC0+c3BkaWZfY2xrKTsKPiArCWNsa19zZXRfcmF0ZShkcC0+c3Bk aWZfY2xrLCBDRE5fRFBfU1BESUZfQ0xLKTsKPiArfQo+ICsKPiAraW50IGNkbl9kcF9hdWRpb19j b25maWcoc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwLCBzdHJ1Y3QgYXVkaW9faW5mbyAqYXVkaW8p Cj4gK3sKPiArCWludCByZXQ7Cj4gKwo+ICsJLyogcmVzZXQgdGhlIHNwZGlmIGNsayBiZWZvcmUg Y29uZmlnICovCj4gKwlpZiAoYXVkaW8tPmZvcm1hdCA9PSBBRk1UX1NQRElGKSB7Cj4gKwkJcmVz ZXRfY29udHJvbF9hc3NlcnQoZHAtPnNwZGlmX3JzdCk7Cj4gKwkJcmVzZXRfY29udHJvbF9kZWFz c2VydChkcC0+c3BkaWZfcnN0KTsKPiArCX0KPiArCj4gKwlyZXQgPSBjZG5fZHBfcmVnX3dyaXRl KGRwLCBDTV9MQU5FX0NUUkwsIExBTkVfUkVGX0NZQyk7Cj4gKwlpZiAocmV0KQo+ICsJCWdvdG8g ZXJyX2F1ZGlvX2NvbmZpZzsKPiArCj4gKwlyZXQgPSBjZG5fZHBfcmVnX3dyaXRlKGRwLCBDTV9D VFJMLCAwKTsKPiArCWlmIChyZXQpCj4gKwkJZ290byBlcnJfYXVkaW9fY29uZmlnOwo+ICsKPiAr CWlmIChhdWRpby0+Zm9ybWF0ID09IEFGTVRfSTJTKQo+ICsJCWNkbl9kcF9hdWRpb19jb25maWdf aTJzKGRwLCBhdWRpbyk7Cj4gKwllbHNlCj4gKwkJY2RuX2RwX2F1ZGlvX2NvbmZpZ19zcGRpZihk cCk7Cj4gKwo+ICsJcmV0ID0gY2RuX2RwX3JlZ193cml0ZShkcCwgQVVESU9fUEFDS19DT05UUk9M LCBBVURJT19QQUNLX0VOKTsKPiArCj4gK2Vycl9hdWRpb19jb25maWc6Cj4gKwlpZiAocmV0KQo+ ICsJCWRldl9lcnIoZHAtPmRldiwgImF1ZGlvIGNvbmZpZyBmYWlsZWQ6ICVkXG4iLCByZXQpOwo+ ICsJcmV0dXJuIHJldDsKPiArfQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcm9ja2No aXAvY2RuLWRwLXJlZy5oIGIvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL2Nkbi1kcC1yZWcuaAo+ IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMC4uNmFjMzY3NAo+IC0tLSAvZGV2 L251bGwKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvY2RuLWRwLXJlZy5oCj4gQEAg LTAsMCArMSw0ODIgQEAKPiArLyoKPiArICogQ29weXJpZ2h0IChDKSBGdXpob3UgUm9ja2NoaXAg RWxlY3Ryb25pY3MgQ28uTHRkCj4gKyAqIEF1dGhvcjogQ2hyaXMgWmhvbmcgPHp5d0Byb2NrLWNo aXBzLmNvbT4KPiArICoKPiArICogVGhpcyBzb2Z0d2FyZSBpcyBsaWNlbnNlZCB1bmRlciB0aGUg dGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYwo+ICsgKiBMaWNlbnNlIHZlcnNpb24gMiwg YXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIGFuZAo+ICsgKiBt YXkgYmUgY29waWVkLCBkaXN0cmlidXRlZCwgYW5kIG1vZGlmaWVkIHVuZGVyIHRob3NlIHRlcm1z Lgo+ICsgKgo+ICsgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhh dCBpdCB3aWxsIGJlIHVzZWZ1bCwKPiArICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRo b3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKPiArICogTUVSQ0hBTlRBQklMSVRZIG9y IEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQo+ICsgKiBHTlUgR2Vu ZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgo+ICsgKi8KPiArCj4gKyNpZm5k ZWYgX0NETl9EUF9SRUdfSAo+ICsjZGVmaW5lIF9DRE5fRFBfUkVHX0gKPiArCj4gKyNpbmNsdWRl IDxsaW51eC9iaXRvcHMuaD4KPiArCj4gKyNkZWZpbmUgQUREUl9JTUVNCQkweDEwMDAwCj4gKyNk ZWZpbmUgQUREUl9ETUVNCQkweDIwMDAwCj4gKwo+ICsvKiBBUEIgQ0ZHIGFkZHIgKi8KPiArI2Rl ZmluZSBBUEJfQ1RSTAkJCTAKPiArI2RlZmluZSBYVF9JTlRfQ1RSTAkJCTB4MDQKPiArI2RlZmlu ZSBNQUlMQk9YX0ZVTExfQUREUgkJMHgwOAo+ICsjZGVmaW5lIE1BSUxCT1hfRU1QVFlfQUREUgkJ MHgwYwo+ICsjZGVmaW5lIE1BSUxCT1gwX1dSX0RBVEEJCTB4MTAKPiArI2RlZmluZSBNQUlMQk9Y MF9SRF9EQVRBCQkweDE0Cj4gKyNkZWZpbmUgS0VFUF9BTElWRQkJCTB4MTgKPiArI2RlZmluZSBW RVJfTAkJCQkweDFjCj4gKyNkZWZpbmUgVkVSX0gJCQkJMHgyMAo+ICsjZGVmaW5lIFZFUl9MSUJf TF9BRERSCQkJMHgyNAo+ICsjZGVmaW5lIFZFUl9MSUJfSF9BRERSCQkJMHgyOAo+ICsjZGVmaW5l IFNXX0RFQlVHX0wJCQkweDJjCj4gKyNkZWZpbmUgU1dfREVCVUdfSAkJCTB4MzAKPiArI2RlZmlu ZSBNQUlMQk9YX0lOVF9NQVNLCQkweDM0Cj4gKyNkZWZpbmUgTUFJTEJPWF9JTlRfU1RBVFVTCQkw eDM4Cj4gKyNkZWZpbmUgU1dfQ0xLX0wJCQkweDNjCj4gKyNkZWZpbmUgU1dfQ0xLX0gJCQkweDQw Cj4gKyNkZWZpbmUgU1dfRVZFTlRTMAkJCTB4NDQKPiArI2RlZmluZSBTV19FVkVOVFMxCQkJMHg0 OAo+ICsjZGVmaW5lIFNXX0VWRU5UUzIJCQkweDRjCj4gKyNkZWZpbmUgU1dfRVZFTlRTMwkJCTB4 NTAKPiArI2RlZmluZSBYVF9PQ0RfQ1RSTAkJCTB4NjAKPiArI2RlZmluZSBBUEJfSU5UX01BU0sJ CQkweDZjCj4gKyNkZWZpbmUgQVBCX1NUQVRVU19NQVNLCQkJMHg3MAo+ICsKPiArLyogYXVkaW8g ZGVjb2RlciBhZGRyICovCj4gKyNkZWZpbmUgQVVESU9fU1JDX0NOVEwJCQkweDMwMDAwCj4gKyNk ZWZpbmUgQVVESU9fU1JDX0NORkcJCQkweDMwMDA0Cj4gKyNkZWZpbmUgQ09NX0NIX1NUVFNfQklU UwkJMHgzMDAwOAo+ICsjZGVmaW5lIFNUVFNfQklUX0NIKHgpCQkJKDB4MzAwMGMgKyAoKHgpIDw8 IDIpKQo+ICsjZGVmaW5lIFNQRElGX0NUUkxfQUREUgkJCTB4MzAwNGMKPiArI2RlZmluZSBTUERJ Rl9DSDFfQ1NfMzEwMF9BRERSCQkweDMwMDUwCj4gKyNkZWZpbmUgU1BESUZfQ0gxX0NTXzYzMzJf QUREUgkJMHgzMDA1NAo+ICsjZGVmaW5lIFNQRElGX0NIMV9DU185NTY0X0FERFIJCTB4MzAwNTgK PiArI2RlZmluZSBTUERJRl9DSDFfQ1NfMTI3OTZfQUREUgkJMHgzMDA1Ywo+ICsjZGVmaW5lIFNQ RElGX0NIMV9DU18xNTkxMjhfQUREUgkweDMwMDYwCj4gKyNkZWZpbmUgU1BESUZfQ0gxX0NTXzE5 MTE2MF9BRERSCTB4MzAwNjQKPiArI2RlZmluZSBTUERJRl9DSDJfQ1NfMzEwMF9BRERSCQkweDMw MDY4Cj4gKyNkZWZpbmUgU1BESUZfQ0gyX0NTXzYzMzJfQUREUgkJMHgzMDA2Ywo+ICsjZGVmaW5l IFNQRElGX0NIMl9DU185NTY0X0FERFIJCTB4MzAwNzAKPiArI2RlZmluZSBTUERJRl9DSDJfQ1Nf MTI3OTZfQUREUgkJMHgzMDA3NAo+ICsjZGVmaW5lIFNQRElGX0NIMl9DU18xNTkxMjhfQUREUgkw eDMwMDc4Cj4gKyNkZWZpbmUgU1BESUZfQ0gyX0NTXzE5MTE2MF9BRERSCTB4MzAwN2MKPiArI2Rl ZmluZSBTTVBMMlBLVF9DTlRMCQkJMHgzMDA4MAo+ICsjZGVmaW5lIFNNUEwyUEtUX0NORkcJCQkw eDMwMDg0Cj4gKyNkZWZpbmUgRklGT19DTlRMCQkJMHgzMDA4OAo+ICsjZGVmaW5lIEZJRk9fU1RU UwkJCTB4MzAwOGMKPiArCj4gKy8qIHNvdXJjZSBwaWYgYWRkciAqLwo+ICsjZGVmaW5lIFNPVVJD RV9QSUZfV1JfQUREUgkJMHgzMDgwMAo+ICsjZGVmaW5lIFNPVVJDRV9QSUZfV1JfUkVRCQkweDMw ODA0Cj4gKyNkZWZpbmUgU09VUkNFX1BJRl9SRF9BRERSCQkweDMwODA4Cj4gKyNkZWZpbmUgU09V UkNFX1BJRl9SRF9SRVEJCTB4MzA4MGMKPiArI2RlZmluZSBTT1VSQ0VfUElGX0RBVEFfV1IJCTB4 MzA4MTAKPiArI2RlZmluZSBTT1VSQ0VfUElGX0RBVEFfUkQJCTB4MzA4MTQKPiArI2RlZmluZSBT T1VSQ0VfUElGX0ZJRk8xX0ZMVVNICQkweDMwODE4Cj4gKyNkZWZpbmUgU09VUkNFX1BJRl9GSUZP Ml9GTFVTSAkJMHgzMDgxYwo+ICsjZGVmaW5lIFNPVVJDRV9QSUZfU1RBVFVTCQkweDMwODIwCj4g KyNkZWZpbmUgU09VUkNFX1BJRl9JTlRFUlJVUFRfU09VUkNFCTB4MzA4MjQKPiArI2RlZmluZSBT T1VSQ0VfUElGX0lOVEVSUlVQVF9NQVNLCTB4MzA4MjgKPiArI2RlZmluZSBTT1VSQ0VfUElGX1BL VF9BTExPQ19SRUcJMHgzMDgyYwo+ICsjZGVmaW5lIFNPVVJDRV9QSUZfUEtUX0FMTE9DX1dSX0VO CTB4MzA4MzAKPiArI2RlZmluZSBTT1VSQ0VfUElGX1NXX1JFU0VUCQkweDMwODM0Cj4gKwo+ICsv KiBiZWxsb3cgcmVnaXN0ZXJzIG5lZWQgYWNjZXNzIGJ5IG1haWxib3ggKi8KPiArLyogc291cmNl IGNhciBhZGRyICovCj4gKyNkZWZpbmUgU09VUkNFX0hEVFhfQ0FSCQkJMHgwOTAwCj4gKyNkZWZp bmUgU09VUkNFX0RQVFhfQ0FSCQkJMHgwOTA0Cj4gKyNkZWZpbmUgU09VUkNFX1BIWV9DQVIJCQkw eDA5MDgKPiArI2RlZmluZSBTT1VSQ0VfQ0VDX0NBUgkJCTB4MDkwYwo+ICsjZGVmaW5lIFNPVVJD RV9DQlVTX0NBUgkJCTB4MDkxMAo+ICsjZGVmaW5lIFNPVVJDRV9QS1RfQ0FSCQkJMHgwOTE4Cj4g KyNkZWZpbmUgU09VUkNFX0FJRl9DQVIJCQkweDA5MWMKPiArI2RlZmluZSBTT1VSQ0VfQ0lQSEVS X0NBUgkJMHgwOTIwCj4gKyNkZWZpbmUgU09VUkNFX0NSWVBUT19DQVIJCTB4MDkyNAo+ICsKPiAr LyogY2xvY2sgbWV0ZXJzIGFkZHIgKi8KPiArI2RlZmluZSBDTV9DVFJMCQkJCTB4MGEwMAo+ICsj ZGVmaW5lIENNX0kyU19DVFJMCQkJMHgwYTA0Cj4gKyNkZWZpbmUgQ01fU1BESUZfQ1RSTAkJCTB4 MGEwOAo+ICsjZGVmaW5lIENNX1ZJRF9DVFJMCQkJMHgwYTBjCj4gKyNkZWZpbmUgQ01fTEFORV9D VFJMCQkJMHgwYTEwCj4gKyNkZWZpbmUgSTJTX05NX1NUQUJMRQkJCTB4MGExNAo+ICsjZGVmaW5l IEkyU19OQ1RTX1NUQUJMRQkJCTB4MGExOAo+ICsjZGVmaW5lIFNQRElGX05NX1NUQUJMRQkJCTB4 MGExYwo+ICsjZGVmaW5lIFNQRElGX05DVFNfU1RBQkxFCQkweDBhMjAKPiArI2RlZmluZSBOTVZJ RF9NRUFTX1NUQUJMRQkJMHgwYTI0Cj4gKyNkZWZpbmUgSTJTX01FQVMJCQkweDBhNDAKPiArI2Rl ZmluZSBTUERJRl9NRUFTCQkJMHgwYTgwCj4gKyNkZWZpbmUgTk1WSURfTUVBUwkJCTB4MGFjMAo+ ICsKPiArLyogc291cmNlIHZpZiBhZGRyICovCj4gKyNkZWZpbmUgQk5EX0hTWU5DMlZTWU5DCQkJ MHgwYjAwCj4gKyNkZWZpbmUgSFNZTkMyVlNZTkNfRjFfTDEJCTB4MGIwNAo+ICsjZGVmaW5lIEhT WU5DMlZTWU5DX0YyX0wxCQkweDBiMDgKPiArI2RlZmluZSBIU1lOQzJWU1lOQ19TVEFUVVMJCTB4 MGIwYwo+ICsjZGVmaW5lIEhTWU5DMlZTWU5DX1BPTF9DVFJMCQkweDBiMTAKPiArCj4gKy8qIGRw dHggcGh5IGFkZHIgKi8KPiArI2RlZmluZSBEUF9UWF9QSFlfQ09ORklHX1JFRwkJMHgyMDAwCj4g KyNkZWZpbmUgRFBfVFhfUEhZX1NUQVRVU19SRUcJCTB4MjAwNAo+ICsjZGVmaW5lIERQX1RYX1BI WV9TV19SRVNFVAkJMHgyMDA4Cj4gKyNkZWZpbmUgRFBfVFhfUEhZX1NDUkFNQkxFUl9TRUVECTB4 MjAwYwo+ICsjZGVmaW5lIERQX1RYX1BIWV9UUkFJTklOR18wMV8wNAkweDIwMTAKPiArI2RlZmlu ZSBEUF9UWF9QSFlfVFJBSU5JTkdfMDVfMDgJMHgyMDE0Cj4gKyNkZWZpbmUgRFBfVFhfUEhZX1RS QUlOSU5HXzA5XzEwCTB4MjAxOAo+ICsjZGVmaW5lIFRFU1RfQ09SCQkJMHgyM2ZjCj4gKwo+ICsv KiBkcHR4IGhwZCBhZGRyICovCj4gKyNkZWZpbmUgSFBEX0lSUV9ERVRfTUlOX1RJTUVSCQkweDIx MDAKPiArI2RlZmluZSBIUERfSVJRX0RFVF9NQVhfVElNRVIJCTB4MjEwNAo+ICsjZGVmaW5lIEhQ RF9VTlBMR0VEX0RFVF9NSU5fVElNRVIJMHgyMTA4Cj4gKyNkZWZpbmUgSFBEX1NUQUJMRV9USU1F UgkJMHgyMTBjCj4gKyNkZWZpbmUgSFBEX0ZJTFRFUl9USU1FUgkJMHgyMTEwCj4gKyNkZWZpbmUg SFBEX0VWRU5UX01BU0sJCQkweDIxMWMKPiArI2RlZmluZSBIUERfRVZFTlRfREVUCQkJMHgyMTIw Cj4gKwo+ICsvKiBkcHl4IGZyYW1lciBhZGRyICovCj4gKyNkZWZpbmUgRFBfRlJBTUVSX0dMT0JB TF9DT05GSUcJCTB4MjIwMAo+ICsjZGVmaW5lIERQX1NXX1JFU0VUCQkJMHgyMjA0Cj4gKyNkZWZp bmUgRFBfRlJBTUVSX1RVCQkJMHgyMjA4Cj4gKyNkZWZpbmUgRFBfRlJBTUVSX1BYTF9SRVBSCQkw eDIyMGMKPiArI2RlZmluZSBEUF9GUkFNRVJfU1AJCQkweDIyMTAKPiArI2RlZmluZSBBVURJT19Q QUNLX0NPTlRST0wJCTB4MjIxNAo+ICsjZGVmaW5lIERQX1ZDX1RBQkxFKHgpCQkJKDB4MjIxOCAr ICgoeCkgPDwgMikpCj4gKyNkZWZpbmUgRFBfVkJfSUQJCQkweDIyNTgKPiArI2RlZmluZSBEUF9N VFBIX0xWUF9DT05UUk9MCQkweDIyNWMKPiArI2RlZmluZSBEUF9NVFBIX1NZTUJPTF9WQUxVRVMJ CTB4MjI2MAo+ICsjZGVmaW5lIERQX01UUEhfRUNGX0NPTlRST0wJCTB4MjI2NAo+ICsjZGVmaW5l IERQX01UUEhfQUNUX0NPTlRST0wJCTB4MjI2OAo+ICsjZGVmaW5lIERQX01UUEhfU1RBVFVTCQkJ MHgyMjZjCj4gKyNkZWZpbmUgRFBfSU5URVJSVVBUX1NPVVJDRQkJMHgyMjcwCj4gKyNkZWZpbmUg RFBfSU5URVJSVVBUX01BU0sJCTB4MjI3NAo+ICsjZGVmaW5lIERQX0ZST05UX0JBQ0tfUE9SQ0gJ CTB4MjI3OAo+ICsjZGVmaW5lIERQX0JZVEVfQ09VTlQJCQkweDIyN2MKPiArCj4gKy8qIGRwdHgg c3RyZWFtIGFkZHIgKi8KPiArI2RlZmluZSBNU0FfSE9SSVpPTlRBTF8wCQkweDIyODAKPiArI2Rl ZmluZSBNU0FfSE9SSVpPTlRBTF8xCQkweDIyODQKPiArI2RlZmluZSBNU0FfVkVSVElDQUxfMAkJ CTB4MjI4OAo+ICsjZGVmaW5lIE1TQV9WRVJUSUNBTF8xCQkJMHgyMjhjCj4gKyNkZWZpbmUgTVNB X01JU0MJCQkweDIyOTAKPiArI2RlZmluZSBTVFJFQU1fQ09ORklHCQkJMHgyMjk0Cj4gKyNkZWZp bmUgQVVESU9fUEFDS19TVEFUVVMJCTB4MjI5OAo+ICsjZGVmaW5lIFZJRl9TVEFUVVMJCQkweDIy OWMKPiArI2RlZmluZSBQQ0tfU1RVRkZfU1RBVFVTXzAJCTB4MjJhMAo+ICsjZGVmaW5lIFBDS19T VFVGRl9TVEFUVVNfMQkJMHgyMmE0Cj4gKyNkZWZpbmUgSU5GT19QQUNLX1NUQVRVUwkJMHgyMmE4 Cj4gKyNkZWZpbmUgUkFURV9HT1ZFUk5PUl9TVEFUVVMJCTB4MjJhYwo+ICsjZGVmaW5lIERQX0hP UklaT05UQUwJCQkweDIyYjAKPiArI2RlZmluZSBEUF9WRVJUSUNBTF8wCQkJMHgyMmI0Cj4gKyNk ZWZpbmUgRFBfVkVSVElDQUxfMQkJCTB4MjJiOAo+ICsjZGVmaW5lIERQX0JMT0NLX1NEUAkJCTB4 MjJiYwo+ICsKPiArLyogZHB0eCBnbGJsIGFkZHIgKi8KPiArI2RlZmluZSBEUFRYX0xBTkVfRU4J CQkweDIzMDAKPiArI2RlZmluZSBEUFRYX0VOSE5DRAkJCTB4MjMwNAo+ICsjZGVmaW5lIERQVFhf SU5UX01BU0sJCQkweDIzMDgKPiArI2RlZmluZSBEUFRYX0lOVF9TVEFUVVMJCQkweDIzMGMKPiAr Cj4gKy8qIGRwIGF1eCBhZGRyICovCj4gKyNkZWZpbmUgRFBfQVVYX0hPU1RfQ09OVFJPTAkJMHgy ODAwCj4gKyNkZWZpbmUgRFBfQVVYX0lOVEVSUlVQVF9TT1VSQ0UJCTB4MjgwNAo+ICsjZGVmaW5l IERQX0FVWF9JTlRFUlJVUFRfTUFTSwkJMHgyODA4Cj4gKyNkZWZpbmUgRFBfQVVYX1NXQVBfSU5W RVJTSU9OX0NPTlRST0wJMHgyODBjCj4gKyNkZWZpbmUgRFBfQVVYX1NFTkRfTkFDS19UUkFOU0FD VElPTgkweDI4MTAKPiArI2RlZmluZSBEUF9BVVhfQ0xFQVJfUlgJCQkweDI4MTQKPiArI2RlZmlu ZSBEUF9BVVhfQ0xFQVJfVFgJCQkweDI4MTgKPiArI2RlZmluZSBEUF9BVVhfVElNRVJfU1RPUAkJ MHgyODFjCj4gKyNkZWZpbmUgRFBfQVVYX1RJTUVSX0NMRUFSCQkweDI4MjAKPiArI2RlZmluZSBE UF9BVVhfUkVTRVRfU1cJCQkweDI4MjQKPiArI2RlZmluZSBEUF9BVVhfRElWSURFXzJNCQkweDI4 MjgKPiArI2RlZmluZSBEUF9BVVhfVFhfUFJFQUNIQVJHRV9MRU5HVEgJMHgyODJjCj4gKyNkZWZp bmUgRFBfQVVYX0ZSRVFVRU5DWV8xTV9NQVgJCTB4MjgzMAo+ICsjZGVmaW5lIERQX0FVWF9GUkVR VUVOQ1lfMU1fTUlOCQkweDI4MzQKPiArI2RlZmluZSBEUF9BVVhfUlhfUFJFX01JTgkJMHgyODM4 Cj4gKyNkZWZpbmUgRFBfQVVYX1JYX1BSRV9NQVgJCTB4MjgzYwo+ICsjZGVmaW5lIERQX0FVWF9U SU1FUl9QUkVTRVQJCTB4Mjg0MAo+ICsjZGVmaW5lIERQX0FVWF9OQUNLX0ZPUk1BVAkJMHgyODQ0 Cj4gKyNkZWZpbmUgRFBfQVVYX1RYX0RBVEEJCQkweDI4NDgKPiArI2RlZmluZSBEUF9BVVhfUlhf REFUQQkJCTB4Mjg0Ywo+ICsjZGVmaW5lIERQX0FVWF9UWF9TVEFUVVMJCTB4Mjg1MAo+ICsjZGVm aW5lIERQX0FVWF9SWF9TVEFUVVMJCTB4Mjg1NAo+ICsjZGVmaW5lIERQX0FVWF9SWF9DWUNMRV9D T1VOVEVSCQkweDI4NTgKPiArI2RlZmluZSBEUF9BVVhfTUFJTl9TVEFURVMJCTB4Mjg1Ywo+ICsj ZGVmaW5lIERQX0FVWF9NQUlOX1RJTUVSCQkweDI4NjAKPiArI2RlZmluZSBEUF9BVVhfQUZFX09V VAkJCTB4Mjg2NAo+ICsKPiArLyogY3J5cHRvIGFkZHIgKi8KPiArI2RlZmluZSBDUllQVE9fSERD UF9SRVZJU0lPTgkJMHg1ODAwCj4gKyNkZWZpbmUgSERDUF9DUllQVE9fQ09ORklHCQkweDU4MDQK PiArI2RlZmluZSBDUllQVE9fSU5URVJSVVBUX1NPVVJDRQkJMHg1ODA4Cj4gKyNkZWZpbmUgQ1JZ UFRPX0lOVEVSUlVQVF9NQVNLCQkweDU4MGMKPiArI2RlZmluZSBDUllQVE8yMl9DT05GSUcJCQkw eDU4MTgKPiArI2RlZmluZSBDUllQVE8yMl9TVEFUVVMJCQkweDU4MWMKPiArI2RlZmluZSBTSEFf MjU2X0RBVEFfSU4JCQkweDU4M2MKPiArI2RlZmluZSBTSEFfMjU2X0RBVEFfT1VUXyh4KQkJKDB4 NTg1MCArICgoeCkgPDwgMikpCj4gKyNkZWZpbmUgQUVTXzMyX0tFWV8oeCkJCQkoMHg1ODcwICsg KCh4KSA8PCAyKSkKPiArI2RlZmluZSBBRVNfMzJfREFUQV9JTgkJCTB4NTg4MAo+ICsjZGVmaW5l IEFFU18zMl9EQVRBX09VVF8oeCkJCSgweDU4ODQgKyAoKHgpIDw8IDIpKQo+ICsjZGVmaW5lIENS WVBUTzE0X0NPTkZJRwkJCTB4NThhMAo+ICsjZGVmaW5lIENSWVBUTzE0X1NUQVRVUwkJCTB4NThh NAo+ICsjZGVmaW5lIENSWVBUTzE0X1BSTk1fT1VUCQkweDU4YTgKPiArI2RlZmluZSBDUllQVE8x NF9LTV8wCQkJMHg1OGFjCj4gKyNkZWZpbmUgQ1JZUFRPMTRfS01fMQkJCTB4NThiMAo+ICsjZGVm aW5lIENSWVBUTzE0X0FOXzAJCQkweDU4YjQKPiArI2RlZmluZSBDUllQVE8xNF9BTl8xCQkJMHg1 OGI4Cj4gKyNkZWZpbmUgQ1JZUFRPMTRfWU9VUl9LU1ZfMAkJMHg1OGJjCj4gKyNkZWZpbmUgQ1JZ UFRPMTRfWU9VUl9LU1ZfMQkJMHg1OGMwCj4gKyNkZWZpbmUgQ1JZUFRPMTRfTUlfMAkJCTB4NThj NAo+ICsjZGVmaW5lIENSWVBUTzE0X01JXzEJCQkweDU4YzgKPiArI2RlZmluZSBDUllQVE8xNF9U SV8wCQkJMHg1OGNjCj4gKyNkZWZpbmUgQ1JZUFRPMTRfS0lfMAkJCTB4NThkMAo+ICsjZGVmaW5l IENSWVBUTzE0X0tJXzEJCQkweDU4ZDQKPiArI2RlZmluZSBDUllQVE8xNF9CTE9DS1NfTlVNCQkw eDU4ZDgKPiArI2RlZmluZSBDUllQVE8xNF9LRVlfTUVNX0RBVEFfMAkJMHg1OGRjCj4gKyNkZWZp bmUgQ1JZUFRPMTRfS0VZX01FTV9EQVRBXzEJCTB4NThlMAo+ICsjZGVmaW5lIENSWVBUTzE0X1NI QTFfTVNHX0RBVEEJCTB4NThlNAo+ICsjZGVmaW5lIENSWVBUTzE0X1NIQTFfVl9WQUxVRV8oeCkJ KDB4NThlOCArICgoeCkgPDwgMikpCj4gKyNkZWZpbmUgVFJOR19DVFJMCQkJMHg1OGZjCj4gKyNk ZWZpbmUgVFJOR19EQVRBX1JEWQkJCTB4NTkwMAo+ICsjZGVmaW5lIFRSTkdfREFUQQkJCTB4NTkw NAo+ICsKPiArLyogY2lwaGVyIGFkZHIgKi8KPiArI2RlZmluZSBIRENQX1JFVklTSU9OCQkJMHg2 MDAwMAo+ICsjZGVmaW5lIElOVEVSUlVQVF9TT1VSQ0UJCTB4NjAwMDQKPiArI2RlZmluZSBJTlRF UlJVUFRfTUFTSwkJCTB4NjAwMDgKPiArI2RlZmluZSBIRENQX0NJUEhFUl9DT05GSUcJCTB4NjAw MGMKPiArI2RlZmluZSBBRVNfMTI4X0tFWV8wCQkJMHg2MDAxMAo+ICsjZGVmaW5lIEFFU18xMjhf S0VZXzEJCQkweDYwMDE0Cj4gKyNkZWZpbmUgQUVTXzEyOF9LRVlfMgkJCTB4NjAwMTgKPiArI2Rl ZmluZSBBRVNfMTI4X0tFWV8zCQkJMHg2MDAxYwo+ICsjZGVmaW5lIEFFU18xMjhfUkFORE9NXzAJ CTB4NjAwMjAKPiArI2RlZmluZSBBRVNfMTI4X1JBTkRPTV8xCQkweDYwMDI0Cj4gKyNkZWZpbmUg Q0lQSEVSMTRfS01fMAkJCTB4NjAwMjgKPiArI2RlZmluZSBDSVBIRVIxNF9LTV8xCQkJMHg2MDAy Ywo+ICsjZGVmaW5lIENJUEhFUjE0X1NUQVRVUwkJCTB4NjAwMzAKPiArI2RlZmluZSBDSVBIRVIx NF9SSV9QSl9TVEFUVVMJCTB4NjAwMzQKPiArI2RlZmluZSBDSVBIRVJfTU9ERQkJCTB4NjAwMzgK PiArI2RlZmluZSBDSVBIRVIxNF9BTl8wCQkJMHg2MDAzYwo+ICsjZGVmaW5lIENJUEhFUjE0X0FO XzEJCQkweDYwMDQwCj4gKyNkZWZpbmUgQ0lQSEVSMjJfQVVUSAkJCTB4NjAwNDQKPiArI2RlZmlu ZSBDSVBIRVIxNF9SMF9EUF9TVEFUVVMJCTB4NjAwNDgKPiArI2RlZmluZSBDSVBIRVIxNF9CT09U U1RSQVAJCTB4NjAwNGMKPiArCj4gKyNkZWZpbmUgRFBUWF9GUk1SX0RBVEFfQ0xLX1JTVE5fRU4J QklUKDExKQo+ICsjZGVmaW5lIERQVFhfRlJNUl9EQVRBX0NMS19FTgkJQklUKDEwKQo+ICsjZGVm aW5lIERQVFhfUEhZX0RBVEFfUlNUTl9FTgkJQklUKDkpCj4gKyNkZWZpbmUgRFBUWF9QSFlfREFU QV9DTEtfRU4JCUJJVCg4KQo+ICsjZGVmaW5lIERQVFhfUEhZX0NIQVJfUlNUTl9FTgkJQklUKDcp Cj4gKyNkZWZpbmUgRFBUWF9QSFlfQ0hBUl9DTEtfRU4JCUJJVCg2KQo+ICsjZGVmaW5lIFNPVVJD RV9BVVhfU1lTX0NMS19SU1ROX0VOCUJJVCg1KQo+ICsjZGVmaW5lIFNPVVJDRV9BVVhfU1lTX0NM S19FTgkJQklUKDQpCj4gKyNkZWZpbmUgRFBUWF9TWVNfQ0xLX1JTVE5fRU4JCUJJVCgzKQo+ICsj ZGVmaW5lIERQVFhfU1lTX0NMS19FTgkJCUJJVCgyKQo+ICsjZGVmaW5lIENGR19EUFRYX1ZJRl9D TEtfUlNUTl9FTglCSVQoMSkKPiArI2RlZmluZSBDRkdfRFBUWF9WSUZfQ0xLX0VOCQlCSVQoMCkK PiArCj4gKyNkZWZpbmUgU09VUkNFX1BIWV9SU1ROX0VOCQlCSVQoMSkKPiArI2RlZmluZSBTT1VS Q0VfUEhZX0NMS19FTgkJQklUKDApCj4gKwo+ICsjZGVmaW5lIFNPVVJDRV9QS1RfU1lTX1JTVE5f RU4JCUJJVCgzKQo+ICsjZGVmaW5lIFNPVVJDRV9QS1RfU1lTX0NMS19FTgkJQklUKDIpCj4gKyNk ZWZpbmUgU09VUkNFX1BLVF9EQVRBX1JTVE5fRU4JCUJJVCgxKQo+ICsjZGVmaW5lIFNPVVJDRV9Q S1RfREFUQV9DTEtfRU4JCUJJVCgwKQo+ICsKPiArI2RlZmluZSBTUERJRl9DRFJfQ0xLX1JTVE5f RU4JCUJJVCg1KQo+ICsjZGVmaW5lIFNQRElGX0NEUl9DTEtfRU4JCUJJVCg0KQo+ICsjZGVmaW5l IFNPVVJDRV9BSUZfU1lTX1JTVE5fRU4JCUJJVCgzKQo+ICsjZGVmaW5lIFNPVVJDRV9BSUZfU1lT X0NMS19FTgkJQklUKDIpCj4gKyNkZWZpbmUgU09VUkNFX0FJRl9DTEtfUlNUTl9FTgkJQklUKDEp Cj4gKyNkZWZpbmUgU09VUkNFX0FJRl9DTEtfRU4JCUJJVCgwKQo+ICsKPiArI2RlZmluZSBTT1VS Q0VfQ0lQSEVSX1NZU1RFTV9DTEtfUlNUTl9FTglCSVQoMykKPiArI2RlZmluZSBTT1VSQ0VfQ0lQ SEVSX1NZU19DTEtfRU4JCUJJVCgyKQo+ICsjZGVmaW5lIFNPVVJDRV9DSVBIRVJfQ0hBUl9DTEtf UlNUTl9FTgkJQklUKDEpCj4gKyNkZWZpbmUgU09VUkNFX0NJUEhFUl9DSEFSX0NMS19FTgkJQklU KDApCj4gKwo+ICsjZGVmaW5lIFNPVVJDRV9DUllQVE9fU1lTX0NMS19SU1ROX0VOCUJJVCgxKQo+ ICsjZGVmaW5lIFNPVVJDRV9DUllQVE9fU1lTX0NMS19FTglCSVQoMCkKPiArCj4gKyNkZWZpbmUg QVBCX0lSQU1fUEFUSAkJCUJJVCgyKQo+ICsjZGVmaW5lIEFQQl9EUkFNX1BBVEgJCQlCSVQoMSkK PiArI2RlZmluZSBBUEJfWFRfUkVTRVQJCQlCSVQoMCkKPiArCj4gKyNkZWZpbmUgTUFJTEJPWF9J TlRfTUFTS19CSVQJCUJJVCgxKQo+ICsjZGVmaW5lIFBJRl9JTlRfTUFTS19CSVQJCUJJVCgwKQo+ ICsjZGVmaW5lIEFMTF9JTlRfTUFTSwkJCTMKPiArCj4gKy8qIG1haWxib3ggKi8KPiArI2RlZmlu ZSBNQl9PUENPREVfSUQJCQkwCj4gKyNkZWZpbmUgTUJfTU9EVUxFX0lECQkJMQo+ICsjZGVmaW5l IE1CX1NJWkVfTVNCX0lECQkJMgo+ICsjZGVmaW5lIE1CX1NJWkVfTFNCX0lECQkJMwo+ICsjZGVm aW5lIE1CX0RBVEFfSUQJCQk0Cj4gKwo+ICsjZGVmaW5lIE1CX01PRFVMRV9JRF9EUF9UWAkJMHgw MQo+ICsjZGVmaW5lIE1CX01PRFVMRV9JRF9IRENQX1RYCQkweDA3Cj4gKyNkZWZpbmUgTUJfTU9E VUxFX0lEX0hEQ1BfUlgJCTB4MDgKPiArI2RlZmluZSBNQl9NT0RVTEVfSURfSERDUF9HRU5FUkFM CTB4MDkKPiArI2RlZmluZSBNQl9NT0RVTEVfSURfR0VORVJBTAkJMHgwYQo+ICsKPiArLyogZ2Vu ZXJhbCBvcGNvZGUgKi8KPiArI2RlZmluZSBHRU5FUkFMX01BSU5fQ09OVFJPTCAgICAgICAgICAg IDB4MDEKPiArI2RlZmluZSBHRU5FUkFMX1RFU1RfRUNITyAgICAgICAgICAgICAgIDB4MDIKPiAr I2RlZmluZSBHRU5FUkFMX0JVU19TRVRUSU5HUyAgICAgICAgICAgIDB4MDMKPiArI2RlZmluZSBH RU5FUkFMX1RFU1RfQUNDRVNTICAgICAgICAgICAgIDB4MDQKPiArCj4gKyNkZWZpbmUgRFBUWF9T RVRfUE9XRVJfTU5HCQkJMHgwMAo+ICsjZGVmaW5lIERQVFhfU0VUX0hPU1RfQ0FQQUJJTElUSUVT CQkweDAxCj4gKyNkZWZpbmUgRFBUWF9HRVRfRURJRAkJCQkweDAyCj4gKyNkZWZpbmUgRFBUWF9S RUFEX0RQQ0QJCQkJMHgwMwo+ICsjZGVmaW5lIERQVFhfV1JJVEVfRFBDRAkJCQkweDA0Cj4gKyNk ZWZpbmUgRFBUWF9FTkFCTEVfRVZFTlQJCQkweDA1Cj4gKyNkZWZpbmUgRFBUWF9XUklURV9SRUdJ U1RFUgkJCTB4MDYKPiArI2RlZmluZSBEUFRYX1JFQURfUkVHSVNURVIJCQkweDA3Cj4gKyNkZWZp bmUgRFBUWF9XUklURV9GSUVMRAkJCTB4MDgKPiArI2RlZmluZSBEUFRYX1RSQUlOSU5HX0NPTlRS T0wJCQkweDA5Cj4gKyNkZWZpbmUgRFBUWF9SRUFEX0VWRU5UCQkJCTB4MGEKPiArI2RlZmluZSBE UFRYX1JFQURfTElOS19TVEFUCQkJMHgwYgo+ICsjZGVmaW5lIERQVFhfU0VUX1ZJREVPCQkJCTB4 MGMKPiArI2RlZmluZSBEUFRYX1NFVF9BVURJTwkJCQkweDBkCj4gKyNkZWZpbmUgRFBUWF9HRVRf TEFTVF9BVVhfU1RBVVMJCQkweDBlCj4gKyNkZWZpbmUgRFBUWF9TRVRfTElOS19CUkVBS19QT0lO VAkJMHgwZgo+ICsjZGVmaW5lIERQVFhfRk9SQ0VfTEFORVMJCQkweDEwCj4gKyNkZWZpbmUgRFBU WF9IUERfU1RBVEUJCQkJMHgxMQo+ICsKPiArI2RlZmluZSBGV19TVEFOREJZCQkJCTAKPiArI2Rl ZmluZSBGV19BQ1RJVkUJCQkJMQo+ICsKPiArI2RlZmluZSBEUFRYX0VWRU5UX0VOQUJMRV9IUEQJ CQlCSVQoMCkKPiArI2RlZmluZSBEUFRYX0VWRU5UX0VOQUJMRV9UUkFJTklORwkJQklUKDEpCj4g Kwo+ICsjZGVmaW5lIExJTktfVFJBSU5JTkdfTk9UX0FDVElWRQkJMAo+ICsjZGVmaW5lIExJTktf VFJBSU5JTkdfUlVOCQkJMQo+ICsjZGVmaW5lIExJTktfVFJBSU5JTkdfUkVTVEFSVAkJCTIKPiAr Cj4gKyNkZWZpbmUgQ09OVFJPTF9WSURFT19JRExFCQkJMAo+ICsjZGVmaW5lIENPTlRST0xfVklE RU9fVkFMSUQJCQkxCj4gKwo+ICsjZGVmaW5lIFZJRl9CWVBBU1NfSU5URVJMQUNFCQkJQklUKDEz KQo+ICsjZGVmaW5lIElOVEVSTEFDRV9GTVRfREVUCQkJQklUKDEyKQo+ICsjZGVmaW5lIElOVEVS TEFDRV9EVENUX1dJTgkJCTB4MjAKPiArCj4gKyNkZWZpbmUgRFBfRlJBTUVSX1NQX0lOVEVSTEFD RV9FTgkJQklUKDIpCj4gKyNkZWZpbmUgRFBfRlJBTUVSX1NQX0hTUAkJCUJJVCgxKQo+ICsjZGVm aW5lIERQX0ZSQU1FUl9TUF9WU1AJCQlCSVQoMCkKPiArCj4gKy8qIGNhcGFiaWxpdHkgKi8KPiAr I2RlZmluZSBBVVhfSE9TVF9JTlZFUlQJCQkJMwo+ICsjZGVmaW5lCUZBU1RfTFRfU1VQUE9SVAkJ CQkxCj4gKyNkZWZpbmUgRkFTVF9MVF9OT1RfU1VQUE9SVAkJCTAKPiArI2RlZmluZSBMQU5FX01B UFBJTkdfTk9STUFMCQkJMHgxYgo+ICsjZGVmaW5lIExBTkVfTUFQUElOR19GTElQUEVECQkJMHhl NAo+ICsjZGVmaW5lIEVOSEFOQ0VECQkJCTEKPiArCj4gKyNkZWZpbmUJRlVMTF9MVF9TVEFSVEVE CQkJCUJJVCgwKQo+ICsjZGVmaW5lIEZBU0VfTFRfU1RBUlRFRAkJCQlCSVQoMSkKPiArI2RlZmlu ZSBDTEtfUkVDT1ZFUllfRklOSVNIRUQJCQlCSVQoMikKPiArI2RlZmluZSBFUV9QSEFTRV9GSU5J U0hFRAkJCUJJVCgzKQo+ICsjZGVmaW5lIEZBU0VfTFRfU1RBUlRfRklOSVNIRUQJCQlCSVQoNCkK PiArI2RlZmluZSBDTEtfUkVDT1ZFUllfRkFJTEVECQkJQklUKDUpCj4gKyNkZWZpbmUgRVFfUEhB U0VfRkFJTEVECQkJCUJJVCg2KQo+ICsjZGVmaW5lIEZBU0VfTFRfRkFJTEVECQkJCUJJVCg3KQo+ ICsKPiArI2RlZmluZSBEUFRYX0hQRF9FVkVOVAkJCQlCSVQoMCkKPiArI2RlZmluZSBEUFRYX1RS QUlOSU5HX0VWRU5UCQkJQklUKDEpCj4gKyNkZWZpbmUgSERDUF9UWF9TVEFUVVNfRVZFTlQJCQlC SVQoNCkKPiArI2RlZmluZSBIRENQMl9UWF9JU19LTV9TVE9SRURfRVZFTlQJCUJJVCg1KQo+ICsj ZGVmaW5lIEhEQ1AyX1RYX1NUT1JFX0tNX0VWRU5UCQkJQklUKDYpCj4gKyNkZWZpbmUgSERDUF9U WF9JU19SRUNFSVZFUl9JRF9WQUxJRF9FVkVOVAlCSVQoNykKPiArCj4gKyNkZWZpbmUgVFVfU0la RQkJCQkJMzAKPiArI2RlZmluZSBDRE5fRFBfTUFYX0xJTktfUkFURQkJCURQX0xJTktfQldfNV80 Cj4gKwo+ICsvKiBhdWRpbyAqLwo+ICsjZGVmaW5lIEFVRElPX1BBQ0tfRU4JCQkJQklUKDgpCj4g KyNkZWZpbmUgU0FNUExJTkdfRlJFUSh4KQkJCSgoKHgpICYgMHhmKSA8PCAxNikKPiArI2RlZmlu ZSBPUklHSU5BTF9TQU1QX0ZSRVEoeCkJCQkoKCh4KSAmIDB4ZikgPDwgMjQpCj4gKyNkZWZpbmUg U1lOQ19XUl9UT19DSF9aRVJPCQkJQklUKDEpCj4gKyNkZWZpbmUgSTJTX0RFQ19TVEFSVAkJCQlC SVQoMSkKPiArI2RlZmluZSBBVURJT19TV19SU1QJCQkJQklUKDApCj4gKyNkZWZpbmUgU01QTDJQ S1RfRU4JCQkJQklUKDEpCj4gKyNkZWZpbmUgTUFYX05VTV9DSCh4KQkJCQkoKCh4KSAmIDB4MWYp IC0gMSkKPiArI2RlZmluZSBOVU1fT0ZfSTJTX1BPUlRTKHgpCQkJKCgoKHgpIC8gMiAtIDEpICYg MHgzKSA8PCA1KQo+ICsjZGVmaW5lIEFVRElPX1RZUEVfTFBDTQkJCQkoMiA8PCA3KQo+ICsjZGVm aW5lIENGR19TVUJfUENLVF9OVU0oeCkJCQkoKCgoeCkgLSAxKSAmIDB4NykgPDwgMTEpCj4gKyNk ZWZpbmUgQVVESU9fQ0hfTlVNKHgpCQkJCSgoKCh4KSAtIDEpICYgMHgxZikgPDwgMikKPiArI2Rl ZmluZSBUUkFOU19TTVBMX1dJRFRIXzE2CQkJMAo+ICsjZGVmaW5lIFRSQU5TX1NNUExfV0lEVEhf MjQJCQlCSVQoMTEpCj4gKyNkZWZpbmUgVFJBTlNfU01QTF9XSURUSF8zMgkJCSgyIDw8IDExKQo+ ICsjZGVmaW5lIEkyU19ERUNfUE9SVF9FTih4KQkJCSgoKHgpICYgMHhmKSA8PCAxNykKPiArI2Rl ZmluZSBTUERJRl9FTkFCTEUJCQkJQklUKDIxKQo+ICsjZGVmaW5lIFNQRElGX0FWR19TRUwJCQkJ QklUKDIwKQo+ICsjZGVmaW5lIFNQRElGX0pJVFRFUl9CWVBBU1MJCQlCSVQoMTkpCj4gKyNkZWZp bmUgU1BESUZfRklGT19NSURfUkFOR0UoeCkJCQkoKCh4KSAmIDB4ZmYpIDw8IDExKQo+ICsjZGVm aW5lIFNQRElGX0pJVFRFUl9USFJTSCh4KQkJCSgoKHgpICYgMHhmZikgPDwgMykKPiArI2RlZmlu ZSBTUERJRl9KSVRURVJfQVZHX1dJTih4KQkJCSgoeCkgJiAweDcpCj4gKwo+ICsvKiBSZWZlcm5j ZSBjeWNsZXMgd2hlbiB1c2luZyBsYW5lIGNsb2NrIGFzIHJlZmVybmNlICovCj4gKyNkZWZpbmUg TEFORV9SRUZfQ1lDCQkJCTB4ODAwMAo+ICsKPiArZW51bSB2b2x0YWdlX3N3aW5nX2xldmVsIHsK PiArCVZPTFRBR0VfTEVWRUxfMCwKPiArCVZPTFRBR0VfTEVWRUxfMSwKPiArCVZPTFRBR0VfTEVW RUxfMiwKPiArCVZPTFRBR0VfTEVWRUxfMywKPiArfTsKPiArCj4gK2VudW0gcHJlX2VtcGhhc2lz X2xldmVsIHsKPiArCVBSRV9FTVBIQVNJU19MRVZFTF8wLAo+ICsJUFJFX0VNUEhBU0lTX0xFVkVM XzEsCj4gKwlQUkVfRU1QSEFTSVNfTEVWRUxfMiwKPiArCVBSRV9FTVBIQVNJU19MRVZFTF8zLAo+ ICt9Owo+ICsKPiArZW51bSBwYXR0ZXJuX3NldCB7Cj4gKwlQVFMxCQk9IEJJVCgwKSwKPiArCVBU UzIJCT0gQklUKDEpLAo+ICsJUFRTMwkJPSBCSVQoMiksCj4gKwlQVFM0CQk9IEJJVCgzKSwKPiAr CURQX05PTkUJCT0gQklUKDQpCj4gK307Cj4gKwo+ICtlbnVtIHZpY19jb2xvcl9kZXB0aCB7Cj4g KwlCQ1NfNiA9IDB4MSwKPiArCUJDU184ID0gMHgyLAo+ICsJQkNTXzEwID0gMHg0LAo+ICsJQkNT XzEyID0gMHg4LAo+ICsJQkNTXzE2ID0gMHgxMCwKPiArfTsKPiArCj4gK2VudW0gdmljX2J0X3R5 cGUgewo+ICsJQlRfNjAxID0gMHgwLAo+ICsJQlRfNzA5ID0gMHgxLAo+ICt9Owo+ICsKPiArdm9p ZCBjZG5fZHBfY2xvY2tfcmVzZXQoc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwKTsKPiArCj4gK3Zv aWQgY2RuX2RwX3NldF9md19jbGsoc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwLCB1MzIgY2xrKTsK PiAraW50IGNkbl9kcF9sb2FkX2Zpcm13YXJlKHN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCwgY29u c3QgdTMyICppX21lbSwKPiArCQkJIHUzMiBpX3NpemUsIGNvbnN0IHUzMiAqZF9tZW0sIHUzMiBk X3NpemUpOwo+ICtpbnQgY2RuX2RwX3NldF9maXJtd2FyZV9hY3RpdmUoc3RydWN0IGNkbl9kcF9k ZXZpY2UgKmRwLCBib29sIGVuYWJsZSk7Cj4gK2ludCBjZG5fZHBfc2V0X2hvc3RfY2FwKHN0cnVj dCBjZG5fZHBfZGV2aWNlICpkcCwgdTggbGFuZXMsIGJvb2wgZmxpcCk7Cj4gK2ludCBjZG5fZHBf ZXZlbnRfY29uZmlnKHN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCk7Cj4gK3UzMiBjZG5fZHBfZ2V0 X2V2ZW50KHN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCk7Cj4gK2ludCBjZG5fZHBfZ2V0X2hwZF9z dGF0dXMoc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwKTsKPiAraW50IGNkbl9kcF9kcGNkX3dyaXRl KHN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCwgdTMyIGFkZHIsIHU4IHZhbHVlKTsKPiAraW50IGNk bl9kcF9kcGNkX3JlYWQoc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwLCB1MzIgYWRkciwgdTggKmRh dGEsIHUxNiBsZW4pOwo+ICtpbnQgY2RuX2RwX2dldF9lZGlkX2Jsb2NrKHZvaWQgKmRwLCB1OCAq ZWRpZCwKPiArCQkJICB1bnNpZ25lZCBpbnQgYmxvY2ssIHNpemVfdCBsZW5ndGgpOwo+ICtpbnQg Y2RuX2RwX3RyYWluaW5nX3N0YXJ0KHN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCk7Cj4gK2ludCBj ZG5fZHBfZ2V0X3RyYWluaW5nX3N0YXR1cyhzdHJ1Y3QgY2RuX2RwX2RldmljZSAqZHApOwo+ICtp bnQgY2RuX2RwX3NldF92aWRlb19zdGF0dXMoc3RydWN0IGNkbl9kcF9kZXZpY2UgKmRwLCBpbnQg YWN0aXZlKTsKPiAraW50IGNkbl9kcF9jb25maWdfdmlkZW8oc3RydWN0IGNkbl9kcF9kZXZpY2Ug KmRwKTsKPiAraW50IGNkbl9kcF9hdWRpb19zdG9wKHN0cnVjdCBjZG5fZHBfZGV2aWNlICpkcCwg c3RydWN0IGF1ZGlvX2luZm8gKmF1ZGlvKTsKPiAraW50IGNkbl9kcF9hdWRpb19tdXRlKHN0cnVj dCBjZG5fZHBfZGV2aWNlICpkcCwgYm9vbCBlbmFibGUpOwo+ICtpbnQgY2RuX2RwX2F1ZGlvX2Nv bmZpZyhzdHJ1Y3QgY2RuX2RwX2RldmljZSAqZHAsIHN0cnVjdCBhdWRpb19pbmZvICphdWRpbyk7 Cj4gKyNlbmRpZiAvKiBfQ0ROX0RQX1JFR19IICovCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9yb2NrY2hpcC9yb2NrY2hpcF9kcm1fdm9wLmMgYi9kcml2ZXJzL2dwdS9kcm0vcm9ja2No aXAvcm9ja2NoaXBfZHJtX3ZvcC5jCj4gaW5kZXggZWRkN2VjMi4uZDcyM2Q4ZSAxMDA2NDQKPiAt LS0gYS9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvcm9ja2NoaXBfZHJtX3ZvcC5jCj4gKysrIGIv ZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL3JvY2tjaGlwX2RybV92b3AuYwo+IEBAIC05NjksOSAr OTY5LDExIEBAIHN0YXRpYyB2b2lkIHZvcF9jcnRjX2VuYWJsZShzdHJ1Y3QgZHJtX2NydGMgKmNy dGMpCj4gICAJCXZvcF9kc3BfaG9sZF92YWxpZF9pcnFfZGlzYWJsZSh2b3ApOwo+ICAgCX0KPiAg IAo+IC0JcGluX3BvbCA9IDB4ODsKPiAtCXBpbl9wb2wgfD0gKGFkanVzdGVkX21vZGUtPmZsYWdz ICYgRFJNX01PREVfRkxBR19OSFNZTkMpID8gMCA6IDE7Cj4gLQlwaW5fcG9sIHw9IChhZGp1c3Rl ZF9tb2RlLT5mbGFncyAmIERSTV9NT0RFX0ZMQUdfTlZTWU5DKSA/IDAgOiAoMSA8PCAxKTsKPiAr CXBpbl9wb2wgPSBCSVQoRENMS19JTlZFUlQpOwo+ICsJcGluX3BvbCB8PSAoYWRqdXN0ZWRfbW9k ZS0+ZmxhZ3MgJiBEUk1fTU9ERV9GTEFHX05IU1lOQykgPwo+ICsJCSAgIDAgOiBCSVQoSFNZTkNf UE9TSVRJVkUpOwo+ICsJcGluX3BvbCB8PSAoYWRqdXN0ZWRfbW9kZS0+ZmxhZ3MgJiBEUk1fTU9E RV9GTEFHX05WU1lOQykgPwo+ICsJCSAgIDAgOiBCSVQoVlNZTkNfUE9TSVRJVkUpOwo+ICAgCVZP UF9DVFJMX1NFVCh2b3AsIHBpbl9wb2wsIHBpbl9wb2wpOwo+ICAgCj4gICAJc3dpdGNoIChzLT5v dXRwdXRfdHlwZSkgewo+IEBAIC05OTEsNiArOTkzLDExIEBAIHN0YXRpYyB2b2lkIHZvcF9jcnRj X2VuYWJsZShzdHJ1Y3QgZHJtX2NydGMgKmNydGMpCj4gICAJCVZPUF9DVFJMX1NFVCh2b3AsIG1p cGlfcGluX3BvbCwgcGluX3BvbCk7Cj4gICAJCVZPUF9DVFJMX1NFVCh2b3AsIG1pcGlfZW4sIDEp Owo+ICAgCQlicmVhazsKPiArCWNhc2UgRFJNX01PREVfQ09OTkVDVE9SX0Rpc3BsYXlQb3J0Ogo+ ICsJCXBpbl9wb2wgJj0gfkJJVChEQ0xLX0lOVkVSVCk7Cj4gKwkJVk9QX0NUUkxfU0VUKHZvcCwg ZHBfcGluX3BvbCwgcGluX3BvbCk7Cj4gKwkJVk9QX0NUUkxfU0VUKHZvcCwgZHBfZW4sIDEpOwo+ ICsJCWJyZWFrOwo+ICAgCWRlZmF1bHQ6Cj4gICAJCURSTV9FUlJPUigidW5zdXBwb3J0IGNvbm5l Y3Rvcl90eXBlWyVkXVxuIiwgcy0+b3V0cHV0X3R5cGUpOwo+ICAgCX0KPiBkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL3JvY2tjaGlwX2RybV92b3AuaCBiL2RyaXZlcnMvZ3B1 L2RybS9yb2NrY2hpcC9yb2NrY2hpcF9kcm1fdm9wLmgKPiBpbmRleCBmZjRmNTJlLi40ODIwYThi IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9yb2NrY2hpcF9kcm1fdm9w LmgKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvcm9ja2NoaXBfZHJtX3ZvcC5oCj4g QEAgLTQ1LDYgKzQ1LDcgQEAgc3RydWN0IHZvcF9jdHJsIHsKPiAgIAlzdHJ1Y3Qgdm9wX3JlZyBl ZHBfZW47Cj4gICAJc3RydWN0IHZvcF9yZWcgaGRtaV9lbjsKPiAgIAlzdHJ1Y3Qgdm9wX3JlZyBt aXBpX2VuOwo+ICsJc3RydWN0IHZvcF9yZWcgZHBfZW47Cj4gICAJc3RydWN0IHZvcF9yZWcgb3V0 X21vZGU7Cj4gICAJc3RydWN0IHZvcF9yZWcgZGl0aGVyX2Rvd247Cj4gICAJc3RydWN0IHZvcF9y ZWcgZGl0aGVyX3VwOwo+IEBAIC01Myw2ICs1NCw3IEBAIHN0cnVjdCB2b3BfY3RybCB7Cj4gICAJ c3RydWN0IHZvcF9yZWcgaGRtaV9waW5fcG9sOwo+ICAgCXN0cnVjdCB2b3BfcmVnIGVkcF9waW5f cG9sOwo+ICAgCXN0cnVjdCB2b3BfcmVnIG1pcGlfcGluX3BvbDsKPiArCXN0cnVjdCB2b3BfcmVn IGRwX3Bpbl9wb2w7Cj4gICAKPiAgIAlzdHJ1Y3Qgdm9wX3JlZyBodG90YWxfcHc7Cj4gICAJc3Ry dWN0IHZvcF9yZWcgaGFjdF9zdF9lbmQ7Cj4gQEAgLTI0Miw2ICsyNDQsMTMgQEAgZW51bSBzY2Fs ZV9kb3duX21vZGUgewo+ICAgCVNDQUxFX0RPV05fQVZHID0gMHgxCj4gICB9Owo+ICAgCj4gK2Vu dW0gdm9wX3BvbCB7Cj4gKwlIU1lOQ19QT1NJVElWRSA9IDAsCj4gKwlWU1lOQ19QT1NJVElWRSA9 IDEsCj4gKwlERU5fTkVHQVRJVkUgICA9IDIsCj4gKwlEQ0xLX0lOVkVSVCAgICA9IDMKPiArfTsK PiArCj4gICAjZGVmaW5lIEZSQUNfMTZfMTYobXVsdCwgZGl2KSAgICAoKChtdWx0KSA8PCAxNikg LyAoZGl2KSkKPiAgICNkZWZpbmUgU0NMX0ZUX0RFRkFVTFRfRklYUE9JTlRfU0hJRlQJMTIKPiAg ICNkZWZpbmUgU0NMX01BWF9WU0tJUExJTkVTCQk0Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9yb2NrY2hpcC9yb2NrY2hpcF92b3BfcmVnLmMgYi9kcml2ZXJzL2dwdS9kcm0vcm9ja2No aXAvcm9ja2NoaXBfdm9wX3JlZy5jCj4gaW5kZXggNWIxYWUxZi4uZGNmMTcyZSAxMDA2NDQKPiAt LS0gYS9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvcm9ja2NoaXBfdm9wX3JlZy5jCj4gKysrIGIv ZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL3JvY2tjaGlwX3ZvcF9yZWcuYwo+IEBAIC0yODEsNiAr MjgxLDcgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCB2b3BfZGF0YSByazMyODhfdm9wID0gewo+ICAg c3RhdGljIGNvbnN0IHN0cnVjdCB2b3BfY3RybCByazMzOTlfY3RybF9kYXRhID0gewo+ICAgCS5z dGFuZGJ5ID0gVk9QX1JFRyhSSzMzOTlfU1lTX0NUUkwsIDB4MSwgMjIpLAo+ICAgCS5nYXRlX2Vu ID0gVk9QX1JFRyhSSzMzOTlfU1lTX0NUUkwsIDB4MSwgMjMpLAo+ICsJLmRwX2VuID0gVk9QX1JF RyhSSzMzOTlfU1lTX0NUUkwsIDB4MSwgMTEpLAo+ICAgCS5yZ2JfZW4gPSBWT1BfUkVHKFJLMzM5 OV9TWVNfQ1RSTCwgMHgxLCAxMiksCj4gICAJLmhkbWlfZW4gPSBWT1BfUkVHKFJLMzM5OV9TWVNf Q1RSTCwgMHgxLCAxMyksCj4gICAJLmVkcF9lbiA9IFZPUF9SRUcoUkszMzk5X1NZU19DVFJMLCAw eDEsIDE0KSwKPiBAQCAtMjkwLDYgKzI5MSw3IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3Qgdm9wX2N0 cmwgcmszMzk5X2N0cmxfZGF0YSA9IHsKPiAgIAkuZGF0YV9ibGFuayA9IFZPUF9SRUcoUkszMzk5 X0RTUF9DVFJMMCwgMHgxLCAxOSksCj4gICAJLm91dF9tb2RlID0gVk9QX1JFRyhSSzMzOTlfRFNQ X0NUUkwwLCAweGYsIDApLAo+ICAgCS5yZ2JfcGluX3BvbCA9IFZPUF9SRUcoUkszMzk5X0RTUF9D VFJMMSwgMHhmLCAxNiksCj4gKwkuZHBfcGluX3BvbCA9IFZPUF9SRUcoUkszMzk5X0RTUF9DVFJM MSwgMHhmLCAxNiksCj4gICAJLmhkbWlfcGluX3BvbCA9IFZPUF9SRUcoUkszMzk5X0RTUF9DVFJM MSwgMHhmLCAyMCksCj4gICAJLmVkcF9waW5fcG9sID0gVk9QX1JFRyhSSzMzOTlfRFNQX0NUUkwx LCAweGYsIDI0KSwKPiAgIAkubWlwaV9waW5fcG9sID0gVk9QX1JFRyhSSzMzOTlfRFNQX0NUUkwx LCAweGYsIDI4KSwKCgotLSAK77ytYXJrIFlhbyDlp5rmmbrmg4UKClJvY2tjaGlwIOemj+W3nueR nuiKr+W+rueUteWtkOaciemZkOWFrOWPuAoKRnV6aG91IEhlYWRxdWFydGVycwoKQWRkcjpOby4y MSBCdWlsZGluZywgQSBEaXN0cmljdCwgRnV6aG91CgpTb2Z0d2FyZSBQYXJrLCA4OSBTb2Z0IEF2 ZW51ZSwgVG9uZ3BhbiBSb2FkLAoKR3Vsb3UgRGlzdHJpY3QsIEZ1emhvdSAoMzUwMDAzKQoK5Zyw 5Z2AOuemj+W7uuecgeemj+W3nuW4gumTnOebmOi3r+i9r+S7tuWkp+mBkzg55Y+36L2v5Lu25Zut QeWMujIx5Y+35qW8ICgzNTAwMDMpCgpUZWw677yIODYtMDU5Me+8iTgzOTkxOTA2IC0gODI5NgoK RS1tYWlsOm1hcmsueWFvQHJvY2stY2hpcHMuY29tCgoKX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxA bGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxt YW4vbGlzdGluZm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 From: mark.yao@rock-chips.com (Mark yao) Date: Fri, 12 Aug 2016 10:06:40 +0800 Subject: [v10.1 PATCH 5/5] drm/rockchip: cdn-dp: add cdn DP support for rk3399 In-Reply-To: <1470871932-17419-1-git-send-email-zyw@rock-chips.com> References: <1470785557-21974-6-git-send-email-zyw@rock-chips.com> <1470871932-17419-1-git-send-email-zyw@rock-chips.com> Message-ID: <57AD2F30.9050408@rock-chips.com> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org Hi Chris Looks good for me only tiny problem comment inline. Thanks. On 2016?08?11? 07:32, Chris Zhong wrote: > Add support for cdn DP controller which is embedded in the rk3399 > SoCs. The DP is compliant with DisplayPort Specification, > Version 1.3, This IP is compatible with the rockchip type-c PHY IP. > There is a uCPU in DP controller, it need a firmware to work, > please put the firmware file to /lib/firmware/rockchip/dptx.bin. The > uCPU in charge of aux communication and link training, the host use > mailbox to communicate with the ucpu. > The dclk pin_pol of vop must not be invert for DP. > > Signed-off-by: Chris Zhong > Reviewed-by: Sean Paul > Acked-by: Mark Yao > > --- > > Changes in v10.1: > - support read sink count from DPCD > > Changes in v10: > - control the grf_clk in DP > > Changes in v9: > - do not need reset the phy before power_on > - add a orientation information for set_capability > - retry to read dpcd in 10 seconds > > Changes in v8: > - optimization the err log > > Changes in v7: > - support firmware standby when no dptx connection > - optimization the calculation of tu size and valid symbol > > Changes in v6: > - add a port struct > - select SND_SOC_HDMI_CODEC > - force reset the phy when hpd detected > > Changes in v5: > - alphabetical order > - do not use long, use u32 or u64 > - return MODE_CLOCK_HIGH when requested > actual > - Optimized Coding Style > - add a formula to get better tu size and symbol value. > - modify according to Sean Paul's comments > - fixed the fw_wait always 0 > > Changes in v4: > - use phy framework to control DP phy > - support 2 phys > > Changes in v3: > - use EXTCON_DISP_DP and EXTCON_DISP_DP_ALT cable to get dp port state. > - reset spdif before config it > - modify the firmware clk to 100Mhz > - retry load firmware if fw file is requested too early > > Changes in v2: > - Alphabetic order > - remove excess error message > - use define clk_rate > - check all return value > - remove dev_set_name(dp->dev, "cdn-dp"); > - use schedule_delayed_work > - remove never-called functions > - remove some unnecessary () > > Changes in v1: > - use extcon API > - use hdmi-codec for the DP Asoc > - do not initialize the "ret" > - printk a err log when drm_of_encoder_active_endpoint_id > - modify the dclk pin_pol to a single line > > drivers/gpu/drm/rockchip/Kconfig | 10 + > drivers/gpu/drm/rockchip/Makefile | 1 + > drivers/gpu/drm/rockchip/cdn-dp-core.c | 937 +++++++++++++++++++++++++++ > drivers/gpu/drm/rockchip/cdn-dp-core.h | 104 +++ > drivers/gpu/drm/rockchip/cdn-dp-reg.c | 959 ++++++++++++++++++++++++++++ > drivers/gpu/drm/rockchip/cdn-dp-reg.h | 482 ++++++++++++++ > drivers/gpu/drm/rockchip/rockchip_drm_vop.c | 13 +- > drivers/gpu/drm/rockchip/rockchip_drm_vop.h | 9 + > drivers/gpu/drm/rockchip/rockchip_vop_reg.c | 2 + > 9 files changed, 2514 insertions(+), 3 deletions(-) > create mode 100644 drivers/gpu/drm/rockchip/cdn-dp-core.c > create mode 100644 drivers/gpu/drm/rockchip/cdn-dp-core.h > create mode 100644 drivers/gpu/drm/rockchip/cdn-dp-reg.c > create mode 100644 drivers/gpu/drm/rockchip/cdn-dp-reg.h > > diff --git a/drivers/gpu/drm/rockchip/Kconfig b/drivers/gpu/drm/rockchip/Kconfig > index d30bdc3..20aaafe 100644 > --- a/drivers/gpu/drm/rockchip/Kconfig > +++ b/drivers/gpu/drm/rockchip/Kconfig > @@ -25,6 +25,16 @@ config ROCKCHIP_ANALOGIX_DP > for the Analogix Core DP driver. If you want to enable DP > on RK3288 based SoC, you should selet this option. > > +config ROCKCHIP_CDN_DP > + tristate "Rockchip cdn DP" > + depends on DRM_ROCKCHIP > + select SND_SOC_HDMI_CODEC if SND_SOC > + help > + This selects support for Rockchip SoC specific extensions > + for the cdn DP driver. If you want to enable Dp on > + RK3399 based SoC, you should select this > + option. > + > config ROCKCHIP_DW_HDMI > tristate "Rockchip specific extensions for Synopsys DW HDMI" > depends on DRM_ROCKCHIP > diff --git a/drivers/gpu/drm/rockchip/Makefile b/drivers/gpu/drm/rockchip/Makefile > index 05d0713..abdecd5 100644 > --- a/drivers/gpu/drm/rockchip/Makefile > +++ b/drivers/gpu/drm/rockchip/Makefile > @@ -7,6 +7,7 @@ rockchipdrm-y := rockchip_drm_drv.o rockchip_drm_fb.o \ > rockchipdrm-$(CONFIG_DRM_FBDEV_EMULATION) += rockchip_drm_fbdev.o > > obj-$(CONFIG_ROCKCHIP_ANALOGIX_DP) += analogix_dp-rockchip.o > +obj-$(CONFIG_ROCKCHIP_CDN_DP) += cdn-dp-core.o cdn-dp-reg.o > obj-$(CONFIG_ROCKCHIP_DW_HDMI) += dw_hdmi-rockchip.o > obj-$(CONFIG_ROCKCHIP_DW_MIPI_DSI) += dw-mipi-dsi.o > obj-$(CONFIG_ROCKCHIP_INNO_HDMI) += inno_hdmi.o > diff --git a/drivers/gpu/drm/rockchip/cdn-dp-core.c b/drivers/gpu/drm/rockchip/cdn-dp-core.c > new file mode 100644 > index 0000000..f9a5afb > --- /dev/null > +++ b/drivers/gpu/drm/rockchip/cdn-dp-core.c > @@ -0,0 +1,937 @@ > +/* > + * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd > + * Author: Chris Zhong > + * > + * This software is licensed under the terms of the GNU General Public > + * License version 2, as published by the Free Software Foundation, and > + * may be copied, distributed, and modified under those terms. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include > +#include > + > +#include > + > +#include "cdn-dp-core.h" > +#include "cdn-dp-reg.h" > +#include "rockchip_drm_vop.h" > + > +#define connector_to_dp(c) \ > + container_of(c, struct cdn_dp_device, connector) > + > +#define encoder_to_dp(c) \ > + container_of(c, struct cdn_dp_device, encoder) > + > +/* dp grf register offset */ > +#define GRF_SOC_CON9 0x6224 > +#define DP_SEL_VOP_LIT BIT(12) > +#define GRF_SOC_CON26 0x6268 > +#define UPHY_SEL_BIT 3 > +#define UPHY_SEL_MASK BIT(19) > +#define DPTX_HPD_SEL (3 << 12) > +#define DPTX_HPD_DEL (2 << 12) > +#define DPTX_HPD_SEL_MASK (3 << 28) > + > +#define MAX_FW_WAIT_SECS 64 > +#define CDN_DP_FIRMWARE "rockchip/dptx.bin" > + > +struct cdn_dp_data { > + u8 max_phy; > +}; > + > +struct cdn_dp_data rk3399_cdn_dp = { > + .max_phy = 2, > +}; > + > +static const struct of_device_id cdn_dp_dt_ids[] = { > + { .compatible = "rockchip,rk3399-cdn-dp", > + .data = (void *)&rk3399_cdn_dp }, > + {} > +}; > + > +MODULE_DEVICE_TABLE(of, cdn_dp_dt_ids); > + > +static int cdn_dp_grf_write(struct cdn_dp_device *dp, > + unsigned int reg, unsigned int val) > +{ > + int ret; > + > + ret = clk_prepare_enable(dp->grf_clk); > + if (ret) { > + dev_err(dp->dev, "Failed to prepare_enable grf clock\n"); > + return ret; > + } > + > + ret = regmap_write(dp->grf, reg, val); > + if (ret) { > + dev_err(dp->dev, "Could not write to GRF: %d\n", ret); > + return ret; > + } > + > + clk_disable_unprepare(dp->grf_clk); > + > + return 0; > +} > + > +static int cdn_dp_clk_enable(struct cdn_dp_device *dp) > +{ > + int ret; > + u32 rate; > + > + ret = clk_prepare_enable(dp->pclk); > + if (ret < 0) { > + dev_err(dp->dev, "cannot enable dp pclk %d\n", ret); > + goto err_pclk; > + } > + > + ret = clk_prepare_enable(dp->core_clk); > + if (ret < 0) { > + dev_err(dp->dev, "cannot enable core_clk %d\n", ret); > + goto err_core_clk; > + } > + > + rate = clk_get_rate(dp->core_clk); > + if (rate < 0) { > + dev_err(dp->dev, "get clk rate failed: %d\n", rate); > + goto err_set_rate; > + } > + > + cdn_dp_set_fw_clk(dp, rate); > + > + return 0; > + > +err_set_rate: > + clk_disable_unprepare(dp->core_clk); > +err_core_clk: > + clk_disable_unprepare(dp->pclk); > +err_pclk: > + return ret; > +} > + > +static enum drm_connector_status > +cdn_dp_connector_detect(struct drm_connector *connector, bool force) > +{ > + struct cdn_dp_device *dp = connector_to_dp(connector); > + > + return dp->hpd_status; > +} > + > +static void cdn_dp_connector_destroy(struct drm_connector *connector) > +{ > + drm_connector_unregister(connector); > + drm_connector_cleanup(connector); > +} > + > +static struct drm_connector_funcs cdn_dp_atomic_connector_funcs = { > + .dpms = drm_atomic_helper_connector_dpms, > + .detect = cdn_dp_connector_detect, > + .destroy = cdn_dp_connector_destroy, > + .fill_modes = drm_helper_probe_single_connector_modes, > + .reset = drm_atomic_helper_connector_reset, > + .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, > + .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, > +}; > + > +static int cdn_dp_connector_get_modes(struct drm_connector *connector) > +{ > + struct cdn_dp_device *dp = connector_to_dp(connector); > + struct edid *edid; > + int ret = 0; > + > + edid = drm_do_get_edid(connector, cdn_dp_get_edid_block, dp); > + if (edid) { > + dev_dbg(dp->dev, "got edid: width[%d] x height[%d]\n", > + edid->width_cm, edid->height_cm); > + > + dp->sink_has_audio = drm_detect_monitor_audio(edid); > + ret = drm_add_edid_modes(connector, edid); > + if (ret) { > + drm_mode_connector_update_edid_property(connector, > + edid); > + drm_edid_to_eld(connector, edid); > + } > + kfree(edid); > + } > + > + return ret; > +} > + > +static struct drm_encoder * > + cdn_dp_connector_best_encoder(struct drm_connector *connector) > +{ > + struct cdn_dp_device *dp = connector_to_dp(connector); > + > + return &dp->encoder; > +} I think cdn-dp have a 1:1 relationship between connectors and encoders, Since the commit(c61b93f drm/atomic: Fix remaining places where !funcs->best_encoder is valid), the best_encoder ops can be removed. > + > +static int cdn_dp_connector_mode_valid(struct drm_connector *connector, > + struct drm_display_mode *mode) > +{ > + struct cdn_dp_device *dp = connector_to_dp(connector); > + struct drm_display_info *display_info = &dp->connector.display_info; > + u32 requested = mode->clock * display_info->bpc * 3 / 1000; > + u32 actual, rate, sink_max, source_max = 0; > + u8 lanes, i; > + > + /* find the running port */ > + for (i = 0; i < dp->ports; i++) { > + if (dp->port[i]->phy_status) { > + source_max = dp->port[i]->cap_lanes; > + break; > + } > + } > + > + sink_max = drm_dp_max_lane_count(dp->dpcd); > + lanes = min(source_max, sink_max); > + > + source_max = drm_dp_bw_code_to_link_rate(CDN_DP_MAX_LINK_RATE); > + sink_max = drm_dp_max_link_rate(dp->dpcd); > + rate = min(source_max, sink_max); > + > + actual = rate * lanes / 100; > + > + /* efficiency is about 0.8 */ > + actual = actual * 8 / 10; > + > + if (requested > actual) { > + dev_dbg(dp->dev, "requested=%d, actual=%d, clock=%d\n", > + requested, actual, mode->clock); > + return MODE_CLOCK_HIGH; > + } > + > + return MODE_OK; > +} > + > +static struct drm_connector_helper_funcs cdn_dp_connector_helper_funcs = { > + .get_modes = cdn_dp_connector_get_modes, > + .best_encoder = cdn_dp_connector_best_encoder, > + .mode_valid = cdn_dp_connector_mode_valid, > +}; > + > +static void cdn_dp_commit(struct drm_encoder *encoder) > +{ > + struct cdn_dp_device *dp = encoder_to_dp(encoder); > + int ret; > + > + ret = cdn_dp_training_start(dp); > + if (ret) > + return; > + > + ret = cdn_dp_get_training_status(dp); > + if (ret) > + return; > + > + dev_info(dp->dev, "rate:0x%x, lanes:%d\n", > + dp->link.rate, dp->link.num_lanes); > + > + if (cdn_dp_set_video_status(dp, CONTROL_VIDEO_IDLE)) > + return; > + > + if (cdn_dp_config_video(dp)) > + return; > + > + if (cdn_dp_set_video_status(dp, CONTROL_VIDEO_VALID)) > + return; > + > + dp->dpms_mode = DRM_MODE_DPMS_ON; > +} > + > +static void cdn_dp_encoder_mode_set(struct drm_encoder *encoder, > + struct drm_display_mode *mode, > + struct drm_display_mode *adjusted) > +{ > + struct cdn_dp_device *dp = encoder_to_dp(encoder); > + struct drm_display_info *display_info = &dp->connector.display_info; > + struct rockchip_crtc_state *state; > + struct video_info *video = &dp->video_info; > + int ret, val; > + > + switch (display_info->bpc) { > + case 16: > + case 12: > + case 10: > + video->color_depth = 10; > + break; > + case 6: > + video->color_depth = 6; > + break; > + default: > + video->color_depth = 8; > + break; > + } > + > + video->color_fmt = PXL_RGB; > + > + video->v_sync_polarity = !!(mode->flags & DRM_MODE_FLAG_NVSYNC); > + video->h_sync_polarity = !!(mode->flags & DRM_MODE_FLAG_NHSYNC); > + > + ret = drm_of_encoder_active_endpoint_id(dp->dev->of_node, encoder); > + if (ret < 0) { > + dev_err(dp->dev, "Could not get vop id, %d", ret); > + return; > + } > + > + dev_dbg(dp->dev, "vop %s output to cdn-dp\n", (ret) ? "LIT" : "BIG"); > + state = to_rockchip_crtc_state(encoder->crtc->state); > + if (ret) { > + val = DP_SEL_VOP_LIT | (DP_SEL_VOP_LIT << 16); > + state->output_mode = ROCKCHIP_OUT_MODE_P888; > + } else { > + val = DP_SEL_VOP_LIT << 16; > + state->output_mode = ROCKCHIP_OUT_MODE_AAAA; > + } > + > + ret = cdn_dp_grf_write(dp, GRF_SOC_CON9, val); > + if (ret) > + return; > + > + memcpy(&dp->mode, adjusted, sizeof(*mode)); > +} > + > +static void cdn_dp_encoder_enable(struct drm_encoder *encoder) > +{ > + struct cdn_dp_device *dp = encoder_to_dp(encoder); > + > + if (dp->dpms_mode != DRM_MODE_DPMS_ON) > + cdn_dp_commit(encoder); > +} > + > +static void cdn_dp_encoder_disable(struct drm_encoder *encoder) > +{ > + struct cdn_dp_device *dp = encoder_to_dp(encoder); > + > + dp->dpms_mode = DRM_MODE_DPMS_OFF; > +} > + > +static int > +cdn_dp_encoder_atomic_check(struct drm_encoder *encoder, > + struct drm_crtc_state *crtc_state, > + struct drm_connector_state *conn_state) > +{ > + struct rockchip_crtc_state *s = to_rockchip_crtc_state(crtc_state); > + > + s->output_mode = ROCKCHIP_OUT_MODE_AAAA; > + s->output_type = DRM_MODE_CONNECTOR_DisplayPort; > + > + return 0; > +} > + > +static struct drm_encoder_helper_funcs cdn_dp_encoder_helper_funcs = { > + .mode_set = cdn_dp_encoder_mode_set, > + .enable = cdn_dp_encoder_enable, > + .disable = cdn_dp_encoder_disable, > + .atomic_check = cdn_dp_encoder_atomic_check, > +}; > + > +static struct drm_encoder_funcs cdn_dp_encoder_funcs = { > + .destroy = drm_encoder_cleanup, > +}; > + > +static int cdn_dp_firmware_init(struct cdn_dp_device *dp) > +{ > + int ret; > + const u32 *iram_data, *dram_data; > + const struct firmware *fw = dp->fw; > + const struct cdn_firmware_header *hdr; > + > + hdr = (struct cdn_firmware_header *)fw->data; > + if (fw->size != le32_to_cpu(hdr->size_bytes)) { > + dev_err(dp->dev, "firmware is invalid\n"); > + return -EINVAL; > + } > + > + iram_data = (const u32 *)(fw->data + hdr->header_size); > + dram_data = (const u32 *)(fw->data + hdr->header_size + hdr->iram_size); > + > + ret = cdn_dp_load_firmware(dp, iram_data, hdr->iram_size, > + dram_data, hdr->dram_size); > + if (ret) > + return ret; > + > + ret = cdn_dp_set_firmware_active(dp, true); > + if (ret) { > + dev_err(dp->dev, "active ucpu failed: %d\n", ret); > + return ret; > + } > + > + return cdn_dp_event_config(dp); > +} > + > +static int cdn_dp_init(struct cdn_dp_device *dp) > +{ > + struct device *dev = dp->dev; > + struct device_node *np = dev->of_node; > + struct platform_device *pdev = to_platform_device(dev); > + struct resource *res; > + int ret; > + > + dp->grf = syscon_regmap_lookup_by_phandle(np, "rockchip,grf"); > + if (IS_ERR(dp->grf)) { > + dev_err(dev, "cdn-dp needs rockchip,grf property\n"); > + return PTR_ERR(dp->grf); > + } > + > + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); > + dp->regs = devm_ioremap_resource(dev, res); > + if (IS_ERR(dp->regs)) { > + dev_err(dev, "ioremap reg failed\n"); > + return PTR_ERR(dp->regs); > + } > + > + dp->core_clk = devm_clk_get(dev, "core-clk"); > + if (IS_ERR(dp->core_clk)) { > + dev_err(dev, "cannot get core_clk_dp\n"); > + return PTR_ERR(dp->core_clk); > + } > + > + dp->pclk = devm_clk_get(dev, "pclk"); > + if (IS_ERR(dp->pclk)) { > + dev_err(dev, "cannot get pclk\n"); > + return PTR_ERR(dp->pclk); > + } > + > + dp->spdif_clk = devm_clk_get(dev, "spdif"); > + if (IS_ERR(dp->spdif_clk)) { > + dev_err(dev, "cannot get spdif_clk\n"); > + return PTR_ERR(dp->spdif_clk); > + } > + > + dp->grf_clk = devm_clk_get(dev, "grf"); > + if (IS_ERR(dp->grf_clk)) { > + dev_err(dev, "cannot get grf clk\n"); > + return PTR_ERR(dp->grf_clk); > + } > + > + dp->spdif_rst = devm_reset_control_get(dev, "spdif"); > + if (IS_ERR(dp->spdif_rst)) { > + dev_err(dev, "no spdif reset control found\n"); > + return PTR_ERR(dp->spdif_rst); > + } > + > + dp->dpms_mode = DRM_MODE_DPMS_OFF; > + > + ret = cdn_dp_clk_enable(dp); > + if (ret < 0) > + return ret; > + > + cdn_dp_clock_reset(dp); > + > + return 0; > +} > + > +static int cdn_dp_audio_hw_params(struct device *dev, void *data, > + struct hdmi_codec_daifmt *daifmt, > + struct hdmi_codec_params *params) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + struct audio_info audio = { > + .sample_width = params->sample_width, > + .sample_rate = params->sample_rate, > + .channels = params->channels, > + }; > + int ret; > + > + if (!dp->encoder.crtc) > + return -ENODEV; > + > + switch (daifmt->fmt) { > + case HDMI_I2S: > + audio.format = AFMT_I2S; > + break; > + case HDMI_SPDIF: > + audio.format = AFMT_SPDIF; > + break; > + default: > + dev_err(dev, "%s: Invalid format %d\n", __func__, daifmt->fmt); > + return -EINVAL; > + } > + > + ret = cdn_dp_audio_config(dp, &audio); > + if (!ret) > + dp->audio_info = audio; > + > + return ret; > +} > + > +static void cdn_dp_audio_shutdown(struct device *dev, void *data) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + int ret; > + > + if (!dp->encoder.crtc) > + return; > + > + ret = cdn_dp_audio_stop(dp, &dp->audio_info); > + if (!ret) > + dp->audio_info.format = AFMT_UNUSED; > +} > + > +static int cdn_dp_audio_digital_mute(struct device *dev, void *data, > + bool enable) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + > + if (!dp->encoder.crtc) > + return -ENODEV; > + > + return cdn_dp_audio_mute(dp, enable); > +} > + > +static int cdn_dp_audio_get_eld(struct device *dev, void *data, > + u8 *buf, size_t len) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + struct drm_mode_config *config = &dp->encoder.dev->mode_config; > + struct drm_connector *connector; > + int ret = -ENODEV; > + > + mutex_lock(&config->mutex); > + list_for_each_entry(connector, &config->connector_list, head) { > + if (&dp->encoder == connector->encoder) { > + memcpy(buf, connector->eld, > + min(sizeof(connector->eld), len)); > + ret = 0; > + } > + } > + mutex_unlock(&config->mutex); > + > + return ret; > +} > + > +static const struct hdmi_codec_ops audio_codec_ops = { > + .hw_params = cdn_dp_audio_hw_params, > + .audio_shutdown = cdn_dp_audio_shutdown, > + .digital_mute = cdn_dp_audio_digital_mute, > + .get_eld = cdn_dp_audio_get_eld, > +}; > + > +static int cdn_dp_audio_codec_init(struct cdn_dp_device *dp, > + struct device *dev) > +{ > + struct hdmi_codec_pdata codec_data = { > + .i2s = 1, > + .spdif = 1, > + .ops = &audio_codec_ops, > + .max_i2s_channels = 8, > + }; > + > + dp->audio_pdev = platform_device_register_data( > + dev, HDMI_CODEC_DRV_NAME, PLATFORM_DEVID_AUTO, > + &codec_data, sizeof(codec_data)); > + > + return PTR_ERR_OR_ZERO(dp->audio_pdev); > +} > + > +static int cdn_dp_get_cap_lanes(struct cdn_dp_device *dp, > + struct extcon_dev *edev) > +{ > + bool dfp, dptx; > + u8 lanes; > + > + dfp = extcon_get_state(edev, EXTCON_USB_HOST); > + dptx = extcon_get_state(edev, EXTCON_DISP_DP); > + > + if (dfp && dptx) > + lanes = 2; > + else if (dptx) > + lanes = 4; > + else > + lanes = 0; > + > + return lanes; > +} > + > +static int cdn_dp_pd_event(struct notifier_block *nb, > + unsigned long event, void *priv) > +{ > + struct cdn_dp_port *port; > + > + port = container_of(nb, struct cdn_dp_port, event_nb); > + > + schedule_delayed_work(&port->event_wq, 0); > + > + return 0; > +} > + > +static void cdn_dp_pd_event_wq(struct work_struct *work) > +{ > + struct cdn_dp_port *port = container_of(work, struct cdn_dp_port, > + event_wq.work); > + union extcon_property_value property; > + struct cdn_dp_device *dp = port->dp; > + u8 new_cap_lanes, sink_count, i; > + int ret; > + > + new_cap_lanes = cdn_dp_get_cap_lanes(dp, port->extcon); > + > + if (new_cap_lanes == port->cap_lanes) { > + dev_dbg(dp->dev, "lanes count does not change: %d\n", > + new_cap_lanes); > + > + if (!new_cap_lanes) > + return; > + > + /* > + * Read the sink count from DPCD, if sink count become 0, this > + * phy could be power off. > + */ > + ret = cdn_dp_dpcd_read(dp, DP_SINK_COUNT, > + &sink_count, 1); ret = cdn_dp_dpcd_read(dp, DP_SINK_COUNT, &sink_count, 1); this line is not over 80 characters, no need to become two lines. > + if (ret || sink_count) > + return; > + > + new_cap_lanes = 0; > + } > + > + if (!new_cap_lanes) { > + ret = phy_power_off(port->phy); > + if (ret) { > + dev_err(dp->dev, "phy power off failed: %d", ret); > + return; > + } > + port->phy_status = false; > + port->cap_lanes = 0; > + for (i = 0; i < dp->ports; i++) { > + if (dp->port[i]->phy_status) > + return; > + } > + > + ret = cdn_dp_grf_write(dp, GRF_SOC_CON26, > + DPTX_HPD_SEL_MASK | DPTX_HPD_DEL); > + if (ret) > + return; > + > + dp->hpd_status = connector_status_disconnected; > + drm_helper_hpd_irq_event(dp->drm_dev); > + cdn_dp_set_firmware_active(dp, false); > + return; > + } > + > + /* if other phy is running, do not touch the hpd_status, and return */ > + for (i = 0; i < dp->ports; i++) { > + if (dp->port[i]->phy_status) { > + dev_warn(dp->dev, "busy, phy[%d] is running", > + dp->port[i]->id); > + return; > + } > + } > + > + if (!dp->fw_loaded) { > + ret = request_firmware(&dp->fw, CDN_DP_FIRMWARE, dp->dev); > + if (ret == -ENOENT && dp->fw_wait <= MAX_FW_WAIT_SECS) { > + unsigned long time = msecs_to_jiffies(dp->fw_wait * HZ); > + > + /* > + * If can not find the file, retry to load the firmware > + * in several seconds, if still failed after 1 minute, > + * give up. > + */ > + schedule_delayed_work(&port->event_wq, time); > + dp->fw_wait *= 2; > + return; > + } else if (ret) { > + dev_err(dp->dev, "failed to request firmware: %d\n", > + ret); > + return; > + } > + } else { > + cdn_dp_set_firmware_active(dp, true); > + } > + > + ret = cdn_dp_grf_write(dp, GRF_SOC_CON26, > + (port->id << UPHY_SEL_BIT) | UPHY_SEL_MASK); > + if (ret) > + goto err_phy; > + > + ret = phy_power_on(port->phy); > + if (ret) { > + dev_err(dp->dev, "phy power on failed: %d\n", ret); > + goto err_phy; > + } > + > + port->phy_status = true; > + > + if (!dp->fw_loaded) { > + ret = cdn_dp_firmware_init(dp); > + if (ret) { > + dev_err(dp->dev, "firmware init failed: %d", ret); > + goto err_firmware; > + } > + release_firmware(dp->fw); > + dp->fw_loaded = 1; > + } > + > + ret = cdn_dp_grf_write(dp, GRF_SOC_CON26, > + DPTX_HPD_SEL_MASK | DPTX_HPD_SEL); > + if (ret) > + goto err_firmware; > + > + ret = cdn_dp_get_hpd_status(dp); > + if (ret <= 0) { > + if (!ret) > + dev_err(dp->dev, "hpd does not exist\n"); > + goto err_firmware; > + } > + > + ret = extcon_get_property(port->extcon, EXTCON_DISP_DP, > + EXTCON_PROP_USB_TYPEC_POLARITY, &property); > + if (ret) { > + dev_err(dp->dev, "get property failed\n"); > + goto err_firmware; > + } > + > + ret = cdn_dp_set_host_cap(dp, new_cap_lanes, property.intval); > + if (ret) { > + dev_err(dp->dev, "set host capabilities failed: %d\n", ret); > + goto err_firmware; > + } > + > + /* > + * Native read with retry for link status and receiver capability reads > + * for cases where the sink may still not be ready. > + * > + * Sinks are *supposed* to come up within 1ms from an off state, but > + * some DOCKs need about 5 seconds to power up, so read the dpcd every > + * 100ms, if can not get a good dpcd in 10 seconds, give up. > + */ > + for (i = 0; i < 100; i++) { > + ret = cdn_dp_dpcd_read(dp, 0x000, dp->dpcd, > + DP_RECEIVER_CAP_SIZE); > + if (!ret) { > + dev_dbg(dp->dev, "get dpcd success!\n"); > + > + /* > + * Check sink count here. Then goto power off phy, > + * if sink count is 0. > + */ > + ret = cdn_dp_dpcd_read(dp, DP_SINK_COUNT, > + &sink_count, 1); > + if (ret) > + continue; > + > + sink_count = DP_GET_SINK_COUNT(sink_count); > + if (!sink_count) > + goto err_firmware; > + > + port->cap_lanes = new_cap_lanes; > + dp->hpd_status = connector_status_connected; > + drm_helper_hpd_irq_event(dp->drm_dev); > + return; > + } else if (!extcon_get_state(port->extcon, EXTCON_DISP_DP)) { > + break; > + } > + msleep(100); > + } > + > + dev_err(dp->dev, "get dpcd failed!\n"); > + > +err_firmware: > + ret = phy_power_off(port->phy); > + if (ret) > + dev_err(dp->dev, "phy power off failed: %d", ret); > + else > + port->phy_status = false; > + > +err_phy: > + if (dp->fw_loaded) > + cdn_dp_set_firmware_active(dp, false); > + else > + release_firmware(dp->fw); > +} > + > +static int cdn_dp_bind(struct device *dev, struct device *master, void *data) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + struct drm_encoder *encoder; > + struct drm_connector *connector; > + struct cdn_dp_port *port; > + struct drm_device *drm_dev = data; > + int ret, i; > + > + ret = cdn_dp_init(dp); > + if (ret < 0) > + return ret; > + > + dp->drm_dev = drm_dev; > + dp->hpd_status = connector_status_disconnected; > + dp->fw_wait = 1; > + > + encoder = &dp->encoder; > + > + encoder->possible_crtcs = drm_of_find_possible_crtcs(drm_dev, > + dev->of_node); > + DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder->possible_crtcs); > + > + ret = drm_encoder_init(drm_dev, encoder, &cdn_dp_encoder_funcs, > + DRM_MODE_ENCODER_TMDS, NULL); > + if (ret) { > + DRM_ERROR("failed to initialize encoder with drm\n"); > + return ret; > + } > + > + drm_encoder_helper_add(encoder, &cdn_dp_encoder_helper_funcs); > + > + connector = &dp->connector; > + connector->polled = DRM_CONNECTOR_POLL_HPD; > + connector->dpms = DRM_MODE_DPMS_OFF; > + > + ret = drm_connector_init(drm_dev, connector, > + &cdn_dp_atomic_connector_funcs, > + DRM_MODE_CONNECTOR_DisplayPort); > + if (ret) { > + DRM_ERROR("failed to initialize connector with drm\n"); > + goto err_free_encoder; > + } > + > + drm_connector_helper_add(connector, &cdn_dp_connector_helper_funcs); > + > + ret = drm_mode_connector_attach_encoder(connector, encoder); > + if (ret) { > + DRM_ERROR("failed to attach connector and encoder\n"); > + goto err_free_connector; > + } > + > + cdn_dp_audio_codec_init(dp, dev); > + > + for (i = 0; i < dp->ports; i++) { > + port = dp->port[i]; > + > + port->event_nb.notifier_call = cdn_dp_pd_event; > + INIT_DELAYED_WORK(&port->event_wq, cdn_dp_pd_event_wq); > + ret = extcon_register_notifier(port->extcon, EXTCON_DISP_DP, > + &port->event_nb); > + if (ret) { > + dev_err(dev, "register EXTCON_DISP_DP notifier err\n"); > + return ret; > + } > + > + if (extcon_get_state(port->extcon, EXTCON_DISP_DP)) > + schedule_delayed_work(&port->event_wq, 0); > + } > + > + return 0; > + > +err_free_connector: > + drm_connector_cleanup(connector); > +err_free_encoder: > + drm_encoder_cleanup(encoder); > + return ret; > +} > + > +static void cdn_dp_unbind(struct device *dev, struct device *master, void *data) > +{ > + struct cdn_dp_device *dp = dev_get_drvdata(dev); > + struct drm_encoder *encoder = &dp->encoder; > + struct drm_connector *connector = &dp->connector; > + struct cdn_dp_port *port; > + int i; > + > + platform_device_unregister(dp->audio_pdev); > + cdn_dp_encoder_disable(encoder); > + encoder->funcs->destroy(encoder); > + connector->funcs->destroy(connector); > + > + for (i = 0; i < dp->ports; i++) { > + port = dp->port[i]; > + extcon_unregister_notifier(port->extcon, EXTCON_DISP_DP, > + &port->event_nb); > + } > +} > + > +static const struct component_ops cdn_dp_component_ops = { > + .bind = cdn_dp_bind, > + .unbind = cdn_dp_unbind, > +}; > + > +static int cdn_dp_probe(struct platform_device *pdev) > +{ > + struct device *dev = &pdev->dev; > + const struct of_device_id *match; > + struct cdn_dp_data *dp_data; > + struct cdn_dp_port *port; > + struct cdn_dp_device *dp; > + struct extcon_dev *extcon; > + struct phy *phy; > + int i; > + > + dp = devm_kzalloc(dev, sizeof(*dp), GFP_KERNEL); > + if (!dp) > + return -ENOMEM; > + dp->dev = dev; > + > + match = of_match_node(cdn_dp_dt_ids, pdev->dev.of_node); > + dp_data = (struct cdn_dp_data *)match->data; > + > + for (i = 0; i < dp_data->max_phy; i++) { > + extcon = extcon_get_edev_by_phandle(dev, i); > + phy = devm_of_phy_get_by_index(dev, dev->of_node, i); > + > + if (PTR_ERR(extcon) == -EPROBE_DEFER || > + PTR_ERR(phy) == -EPROBE_DEFER) > + return -EPROBE_DEFER; > + > + if (IS_ERR(extcon) || IS_ERR(phy)) > + continue; > + > + port = devm_kzalloc(dev, sizeof(*port), GFP_KERNEL); > + if (!dp) > + return -ENOMEM; > + > + port->extcon = extcon; > + port->phy = phy; > + port->dp = dp; > + port->id = i; > + dp->port[dp->ports++] = port; > + } > + > + if (!dp->ports) { > + dev_err(dev, "missing extcon or phy\n"); > + return -EINVAL; > + } > + > + dev_set_drvdata(dev, dp); > + > + return component_add(dev, &cdn_dp_component_ops); > +} > + > +static int cdn_dp_remove(struct platform_device *pdev) > +{ > + component_del(&pdev->dev, &cdn_dp_component_ops); > + > + return 0; > +} > + > +static struct platform_driver cdn_dp_driver = { > + .probe = cdn_dp_probe, > + .remove = cdn_dp_remove, > + .driver = { > + .name = "cdn-dp", > + .owner = THIS_MODULE, > + .of_match_table = of_match_ptr(cdn_dp_dt_ids), > + }, > +}; > + > +module_platform_driver(cdn_dp_driver); > + > +MODULE_AUTHOR("Chris Zhong "); > +MODULE_DESCRIPTION("cdn DP Driver"); > +MODULE_LICENSE("GPL v2"); > diff --git a/drivers/gpu/drm/rockchip/cdn-dp-core.h b/drivers/gpu/drm/rockchip/cdn-dp-core.h > new file mode 100644 > index 0000000..0cf23db > --- /dev/null > +++ b/drivers/gpu/drm/rockchip/cdn-dp-core.h > @@ -0,0 +1,104 @@ > +/* > + * Copyright (C) 2016 Chris Zhong > + * Copyright (C) 2016 ROCKCHIP, Inc. > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation; either version 2 of the License. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + */ > + > +#ifndef _CDN_DP_CORE_H > +#define _CDN_DP_CORE_H > + > +#include > +#include > +#include > +#include > +#include "rockchip_drm_drv.h" > + > +#define MAX_PHY 2 > + > +enum audio_format { > + AFMT_I2S = 0, > + AFMT_SPDIF = 1, > + AFMT_UNUSED, > +}; > + > +struct audio_info { > + enum audio_format format; > + int sample_rate; > + int channels; > + int sample_width; > +}; > + > +enum vic_pxl_encoding_format { > + PXL_RGB = 0x1, > + YCBCR_4_4_4 = 0x2, > + YCBCR_4_2_2 = 0x4, > + YCBCR_4_2_0 = 0x8, > + Y_ONLY = 0x10, > +}; > + > +struct video_info { > + bool h_sync_polarity; > + bool v_sync_polarity; > + bool interlaced; > + int color_depth; > + enum vic_pxl_encoding_format color_fmt; > +}; > + > +struct cdn_firmware_header { > + u32 size_bytes; /* size of the entire header+image(s) in bytes */ > + u32 header_size; /* size of just the header in bytes */ > + u32 iram_size; /* size of iram */ > + u32 dram_size; /* size of dram */ > +}; > + > +struct cdn_dp_port { > + struct cdn_dp_device *dp; > + struct notifier_block event_nb; > + struct delayed_work event_wq; > + struct extcon_dev *extcon; > + struct phy *phy; > + u8 cap_lanes; > + bool phy_status; > + u8 id; > +}; > + > +struct cdn_dp_device { > + struct device *dev; > + struct drm_device *drm_dev; > + struct drm_connector connector; > + struct drm_encoder encoder; > + struct drm_display_mode mode; > + struct platform_device *audio_pdev; > + > + const struct firmware *fw; /* cdn dp firmware */ > + unsigned int fw_version; /* cdn fw version */ > + u32 fw_wait; > + bool fw_loaded; > + bool fw_actived; > + void __iomem *regs; > + struct regmap *grf; > + struct clk *core_clk; > + struct clk *pclk; > + struct clk *spdif_clk; > + struct clk *grf_clk; > + struct reset_control *spdif_rst; > + struct audio_info audio_info; > + struct video_info video_info; > + struct drm_dp_link link; > + struct cdn_dp_port *port[MAX_PHY]; > + u8 ports; > + > + u8 dpcd[DP_RECEIVER_CAP_SIZE]; > + enum drm_connector_status hpd_status; > + int dpms_mode; > + bool sink_has_audio; > +}; > +#endif /* _CDN_DP_CORE_H */ > diff --git a/drivers/gpu/drm/rockchip/cdn-dp-reg.c b/drivers/gpu/drm/rockchip/cdn-dp-reg.c > new file mode 100644 > index 0000000..2ea702d > --- /dev/null > +++ b/drivers/gpu/drm/rockchip/cdn-dp-reg.c > @@ -0,0 +1,959 @@ > +/* > + * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd > + * Author: Chris Zhong > + * > + * This software is licensed under the terms of the GNU General Public > + * License version 2, as published by the Free Software Foundation, and > + * may be copied, distributed, and modified under those terms. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include "cdn-dp-core.h" > +#include "cdn-dp-reg.h" > + > +#define CDN_DP_SPDIF_CLK 200000000 > +#define FW_ALIVE_TIMEOUT_US 1000000 > +#define MAILBOX_RETRY_US 1000 > +#define MAILBOX_TIMEOUT_US 5000000 > +#define LINK_TRAINING_RETRY_MS 20 > +#define LINK_TRAINING_TIMEOUT_MS 500 > + > +void cdn_dp_set_fw_clk(struct cdn_dp_device *dp, u32 clk) > +{ > + writel(clk / 1000000, dp->regs + SW_CLK_H); > +} > + > +void cdn_dp_clock_reset(struct cdn_dp_device *dp) > +{ > + u32 val; > + > + val = DPTX_FRMR_DATA_CLK_RSTN_EN | > + DPTX_FRMR_DATA_CLK_EN | > + DPTX_PHY_DATA_RSTN_EN | > + DPTX_PHY_DATA_CLK_EN | > + DPTX_PHY_CHAR_RSTN_EN | > + DPTX_PHY_CHAR_CLK_EN | > + SOURCE_AUX_SYS_CLK_RSTN_EN | > + SOURCE_AUX_SYS_CLK_EN | > + DPTX_SYS_CLK_RSTN_EN | > + DPTX_SYS_CLK_EN | > + CFG_DPTX_VIF_CLK_RSTN_EN | > + CFG_DPTX_VIF_CLK_EN; > + writel(val, dp->regs + SOURCE_DPTX_CAR); > + > + val = SOURCE_PHY_RSTN_EN | SOURCE_PHY_CLK_EN; > + writel(val, dp->regs + SOURCE_PHY_CAR); > + > + val = SOURCE_PKT_SYS_RSTN_EN | > + SOURCE_PKT_SYS_CLK_EN | > + SOURCE_PKT_DATA_RSTN_EN | > + SOURCE_PKT_DATA_CLK_EN; > + writel(val, dp->regs + SOURCE_PKT_CAR); > + > + val = SPDIF_CDR_CLK_RSTN_EN | > + SPDIF_CDR_CLK_EN | > + SOURCE_AIF_SYS_RSTN_EN | > + SOURCE_AIF_SYS_CLK_EN | > + SOURCE_AIF_CLK_RSTN_EN | > + SOURCE_AIF_CLK_EN; > + writel(val, dp->regs + SOURCE_AIF_CAR); > + > + val = SOURCE_CIPHER_SYSTEM_CLK_RSTN_EN | > + SOURCE_CIPHER_SYS_CLK_EN | > + SOURCE_CIPHER_CHAR_CLK_RSTN_EN | > + SOURCE_CIPHER_CHAR_CLK_EN; > + writel(val, dp->regs + SOURCE_CIPHER_CAR); > + > + val = SOURCE_CRYPTO_SYS_CLK_RSTN_EN | > + SOURCE_CRYPTO_SYS_CLK_EN; > + writel(val, dp->regs + SOURCE_CRYPTO_CAR); > + > + val = ~(MAILBOX_INT_MASK_BIT | PIF_INT_MASK_BIT) & ALL_INT_MASK; > + writel(val, dp->regs + APB_INT_MASK); > +} > + > +static int cdn_dp_mailbox_read(struct cdn_dp_device *dp, bool force) > +{ > + int val, ret; > + > + if (!dp->fw_actived && !force) > + return -EPERM; > + > + ret = readx_poll_timeout(readl, dp->regs + MAILBOX_EMPTY_ADDR, > + val, !val, MAILBOX_RETRY_US, > + MAILBOX_TIMEOUT_US); > + if (ret < 0) > + return ret; > + > + return readl(dp->regs + MAILBOX0_RD_DATA) & 0xff; > +} > + > +static int cdp_dp_mailbox_write(struct cdn_dp_device *dp, u8 val, bool force) > +{ > + int ret, full; > + > + if (!dp->fw_actived && !force) > + return -EPERM; > + > + ret = readx_poll_timeout(readl, dp->regs + MAILBOX_FULL_ADDR, > + full, !full, MAILBOX_RETRY_US, > + MAILBOX_TIMEOUT_US); > + if (ret < 0) > + return ret; > + > + writel(val, dp->regs + MAILBOX0_WR_DATA); > + > + return 0; > +} > + > +static int cdn_dp_mailbox_validate_receive(struct cdn_dp_device *dp, > + u8 module_id, u8 opcode, > + u8 req_size) > +{ > + u32 mbox_size, i; > + u8 header[4]; > + int ret; > + > + /* read the header of the message */ > + for (i = 0; i < 4; i++) { > + ret = cdn_dp_mailbox_read(dp, 0); > + if (ret < 0) > + return ret; > + > + header[i] = ret; > + } > + > + mbox_size = (header[2] << 8) | header[3]; > + > + if (opcode != header[0] || module_id != header[1] || > + req_size != mbox_size) { > + /* > + * If the message in mailbox is not what we want, we need to > + * clear the mailbox by read. > + */ > + for (i = 0; i < mbox_size; i++) > + if (cdn_dp_mailbox_read(dp, 0) < 0) > + break; > + > + return -EINVAL; > + } > + > + return 0; > +} > + > +static int cdn_dp_mailbox_read_receive(struct cdn_dp_device *dp, > + u8 *buff, u8 buff_size) > +{ > + u32 i; > + int ret; > + > + for (i = 0; i < buff_size; i++) { > + ret = cdn_dp_mailbox_read(dp, 0); > + if (ret < 0) > + return ret; > + > + buff[i] = ret; > + } > + > + return 0; > +} > + > +static int cdn_dp_mailbox_send(struct cdn_dp_device *dp, u8 module_id, > + u8 opcode, u16 size, u8 *message) > +{ > + u8 header[4]; > + int ret, i; > + > + header[0] = opcode; > + header[1] = module_id; > + header[2] = (size >> 8) & 0xff; > + header[3] = size & 0xff; > + > + for (i = 0; i < 4; i++) { > + ret = cdp_dp_mailbox_write(dp, header[i], 0); > + if (ret) > + return ret; > + } > + > + for (i = 0; i < size; i++) { > + ret = cdp_dp_mailbox_write(dp, message[i], 0); > + if (ret) > + return ret; > + } > + > + return 0; > +} > + > +static int cdn_dp_reg_write(struct cdn_dp_device *dp, u16 addr, u32 val) > +{ > + u8 msg[6]; > + > + msg[0] = (addr >> 8) & 0xff; > + msg[1] = addr & 0xff; > + msg[2] = (val >> 24) & 0xff; > + msg[3] = (val >> 16) & 0xff; > + msg[4] = (val >> 8) & 0xff; > + msg[5] = val & 0xff; > + return cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_WRITE_REGISTER, > + sizeof(msg), msg); > +} > + > +static int cdn_dp_reg_write_bit(struct cdn_dp_device *dp, u16 addr, > + u8 start_bit, u8 bits_no, u32 val) > +{ > + u8 field[8]; > + > + field[0] = (addr >> 8) & 0xff; > + field[1] = addr & 0xff; > + field[2] = start_bit; > + field[3] = bits_no; > + field[4] = (val >> 24) & 0xff; > + field[5] = (val >> 16) & 0xff; > + field[6] = (val >> 8) & 0xff; > + field[7] = val & 0xff; > + > + return cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_WRITE_FIELD, > + sizeof(field), field); > +} > + > +int cdn_dp_dpcd_read(struct cdn_dp_device *dp, u32 addr, u8 *data, u16 len) > +{ > + u8 msg[5], reg[5]; > + int ret; > + > + msg[0] = (len >> 8) & 0xff; > + msg[1] = len & 0xff; > + msg[2] = (addr >> 16) & 0xff; > + msg[3] = (addr >> 8) & 0xff; > + msg[4] = addr & 0xff; > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_READ_DPCD, > + sizeof(msg), msg); > + if (ret) > + goto err_dpcd_read; > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_READ_DPCD, > + sizeof(reg) + len); > + if (ret) > + goto err_dpcd_read; > + > + ret = cdn_dp_mailbox_read_receive(dp, reg, sizeof(reg)); > + if (ret) > + goto err_dpcd_read; > + > + ret = cdn_dp_mailbox_read_receive(dp, data, len); > + > +err_dpcd_read: > + return ret; > +} > + > +int cdn_dp_dpcd_write(struct cdn_dp_device *dp, u32 addr, u8 value) > +{ > + u8 msg[6], reg[5]; > + int ret; > + > + msg[0] = 0; > + msg[1] = 1; > + msg[2] = (addr >> 16) & 0xff; > + msg[3] = (addr >> 8) & 0xff; > + msg[4] = addr & 0xff; > + msg[5] = value; > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_WRITE_DPCD, > + sizeof(msg), msg); > + if (ret) > + goto err_dpcd_write; > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_WRITE_DPCD, sizeof(reg)); > + if (ret) > + goto err_dpcd_write; > + > + ret = cdn_dp_mailbox_read_receive(dp, reg, sizeof(reg)); > + if (ret) > + goto err_dpcd_write; > + > + if (addr != (reg[2] << 16 | reg[3] << 8 | reg[4])) > + ret = -EINVAL; > + > +err_dpcd_write: > + if (ret) > + dev_err(dp->dev, "dpcd write failed: %d\n", ret); > + return ret; > +} > + > +int cdn_dp_load_firmware(struct cdn_dp_device *dp, const u32 *i_mem, > + u32 i_size, const u32 *d_mem, u32 d_size) > +{ > + u32 reg; > + int i, ret; > + > + /* reset ucpu before load firmware*/ > + writel(APB_IRAM_PATH | APB_DRAM_PATH | APB_XT_RESET, > + dp->regs + APB_CTRL); > + > + for (i = 0; i < i_size; i += 4) > + writel(*i_mem++, dp->regs + ADDR_IMEM + i); > + > + for (i = 0; i < d_size; i += 4) > + writel(*d_mem++, dp->regs + ADDR_DMEM + i); > + > + /* un-reset ucpu */ > + writel(0, dp->regs + APB_CTRL); > + > + /* check the keep alive register to make sure fw working */ > + ret = readx_poll_timeout(readl, dp->regs + KEEP_ALIVE, > + reg, reg, 2000, FW_ALIVE_TIMEOUT_US); > + if (ret < 0) { > + dev_err(dp->dev, "failed to loaded the FW reg = %x\n", reg); > + return -EINVAL; > + } > + > + reg = readl(dp->regs + VER_L) & 0xff; > + dp->fw_version = reg; > + reg = readl(dp->regs + VER_H) & 0xff; > + dp->fw_version |= reg << 8; > + reg = readl(dp->regs + VER_LIB_L_ADDR) & 0xff; > + dp->fw_version |= reg << 16; > + reg = readl(dp->regs + VER_LIB_H_ADDR) & 0xff; > + dp->fw_version |= reg << 24; > + > + dev_dbg(dp->dev, "firmware version: %x\n", dp->fw_version); > + > + return 0; > +} > + > +int cdn_dp_set_firmware_active(struct cdn_dp_device *dp, bool enable) > +{ > + u8 msg[5]; > + int ret, i; > + > + msg[0] = GENERAL_MAIN_CONTROL; > + msg[1] = MB_MODULE_ID_GENERAL; > + msg[2] = 0; > + msg[3] = 1; > + msg[4] = enable ? FW_ACTIVE : FW_STANDBY; > + > + for (i = 0; i < sizeof(msg); i++) { > + ret = cdp_dp_mailbox_write(dp, msg[i], 1); > + if (ret) > + goto err_set_firmware_active; > + } > + > + /* read the firmware state */ > + for (i = 0; i < sizeof(msg); i++) { > + ret = cdn_dp_mailbox_read(dp, 1); > + if (ret < 0) > + goto err_set_firmware_active; > + > + msg[i] = ret; > + } > + > + dp->fw_actived = (msg[4] == FW_ACTIVE); > + ret = 0; > + > +err_set_firmware_active: > + if (ret < 0) > + dev_err(dp->dev, "set firmware active failed\n"); > + return ret; > +} > + > +int cdn_dp_set_host_cap(struct cdn_dp_device *dp, u8 lanes, bool flip) > +{ > + u8 msg[8]; > + int ret; > + > + msg[0] = CDN_DP_MAX_LINK_RATE; > + msg[1] = lanes; > + msg[2] = VOLTAGE_LEVEL_2; > + msg[3] = PRE_EMPHASIS_LEVEL_3; > + msg[4] = PTS1 | PTS2 | PTS3 | PTS4; > + msg[5] = FAST_LT_NOT_SUPPORT; > + msg[6] = flip ? LANE_MAPPING_FLIPPED : LANE_MAPPING_NORMAL; > + msg[7] = ENHANCED; > + > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, > + DPTX_SET_HOST_CAPABILITIES, > + sizeof(msg), msg); > + if (ret) > + goto err_set_host_cap; > + > + ret = cdn_dp_reg_write(dp, DP_AUX_SWAP_INVERSION_CONTROL, > + AUX_HOST_INVERT); > + > +err_set_host_cap: > + if (ret) > + dev_err(dp->dev, "set host cap failed: %d\n", ret); > + return ret; > +} > + > +int cdn_dp_event_config(struct cdn_dp_device *dp) > +{ > + u8 msg[5]; > + int ret; > + > + memset(msg, 0, sizeof(msg)); > + > + msg[0] = DPTX_EVENT_ENABLE_HPD | DPTX_EVENT_ENABLE_TRAINING; > + > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_ENABLE_EVENT, > + sizeof(msg), msg); > + if (ret) > + dev_err(dp->dev, "set event config failed: %d\n", ret); > + > + return ret; > +} > + > +u32 cdn_dp_get_event(struct cdn_dp_device *dp) > +{ > + return readl(dp->regs + SW_EVENTS0); > +} > + > +int cdn_dp_get_hpd_status(struct cdn_dp_device *dp) > +{ > + u8 status; > + int ret; > + > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_HPD_STATE, > + 0, NULL); > + if (ret) > + goto err_get_hpd; > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_HPD_STATE, sizeof(status)); > + if (ret) > + goto err_get_hpd; > + > + ret = cdn_dp_mailbox_read_receive(dp, &status, sizeof(status)); > + if (ret) > + goto err_get_hpd; > + > + return status; > + > +err_get_hpd: > + dev_err(dp->dev, "get hpd status failed: %d\n", ret); > + return ret; > +} > + > +int cdn_dp_get_edid_block(void *data, u8 *edid, > + unsigned int block, size_t length) > +{ > + struct cdn_dp_device *dp = data; > + u8 msg[2], reg[2]; > + int ret; > + > + msg[0] = block / 2; > + msg[1] = block % 2; > + > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_GET_EDID, > + sizeof(msg), msg); > + if (ret) > + goto err_get_edid; > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_GET_EDID, > + sizeof(reg) + length); > + if (ret) > + goto err_get_edid; > + > + ret = cdn_dp_mailbox_read_receive(dp, reg, sizeof(reg)); > + if (ret) > + goto err_get_edid; > + > + ret = cdn_dp_mailbox_read_receive(dp, edid, length); > + if (ret) > + goto err_get_edid; > + > + if (reg[0] != length || reg[1] != block / 2) > + ret = -EINVAL; > + > +err_get_edid: > + if (ret) > + dev_err(dp->dev, "get block[%d] edid failed: %d\n", block, ret); > + return ret; > +} > + > +int cdn_dp_training_start(struct cdn_dp_device *dp) > +{ > + unsigned long timeout; > + u8 msg, event[2]; > + int ret; > + > + msg = LINK_TRAINING_RUN; > + > + /* start training */ > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_TRAINING_CONTROL, > + sizeof(msg), &msg); > + if (ret) > + goto err_training_start; > + > + timeout = jiffies + msecs_to_jiffies(LINK_TRAINING_TIMEOUT_MS); > + while (time_before(jiffies, timeout)) { > + msleep(LINK_TRAINING_RETRY_MS); > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, > + DPTX_READ_EVENT, 0, NULL); > + if (ret) > + goto err_training_start; > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_READ_EVENT, > + sizeof(event)); > + if (ret) > + goto err_training_start; > + > + ret = cdn_dp_mailbox_read_receive(dp, event, sizeof(event)); > + if (ret) > + goto err_training_start; > + > + if (event[1] & EQ_PHASE_FINISHED) > + return 0; > + } > + > + ret = -ETIMEDOUT; > + > +err_training_start: > + dev_err(dp->dev, "training failed: %d\n", ret); > + return ret; > +} > + > +int cdn_dp_get_training_status(struct cdn_dp_device *dp) > +{ > + u8 status[10]; > + int ret; > + > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_READ_LINK_STAT, > + 0, NULL); > + if (ret) > + goto err_get_training_status; > + > + ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX, > + DPTX_READ_LINK_STAT, > + sizeof(status)); > + if (ret) > + goto err_get_training_status; > + > + ret = cdn_dp_mailbox_read_receive(dp, status, sizeof(status)); > + if (ret) > + goto err_get_training_status; > + > + dp->link.rate = status[0]; > + dp->link.num_lanes = status[1]; > + > +err_get_training_status: > + if (ret) > + dev_err(dp->dev, "get training status failed: %d\n", ret); > + return ret; > +} > + > +int cdn_dp_set_video_status(struct cdn_dp_device *dp, int active) > +{ > + u8 msg; > + int ret; > + > + msg = !!active; > + > + ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_SET_VIDEO, > + sizeof(msg), &msg); > + if (ret) > + dev_err(dp->dev, "set video status failed: %d\n", ret); > + > + return ret; > +} > + > +static int cdn_dp_get_msa_misc(struct video_info *video, > + struct drm_display_mode *mode) > +{ > + u32 msa_misc; > + u8 val[2]; > + > + switch (video->color_fmt) { > + case PXL_RGB: > + case Y_ONLY: > + val[0] = 0; > + break; > + /* set YUV default color space conversion to BT601 */ > + case YCBCR_4_4_4: > + val[0] = 6 + BT_601 * 8; > + break; > + case YCBCR_4_2_2: > + val[0] = 5 + BT_601 * 8; > + break; > + case YCBCR_4_2_0: > + val[0] = 5; > + break; > + }; > + > + switch (video->color_depth) { > + case 6: > + val[1] = 0; > + break; > + case 8: > + val[1] = 1; > + break; > + case 10: > + val[1] = 2; > + break; > + case 12: > + val[1] = 3; > + break; > + case 16: > + val[1] = 4; > + break; > + }; > + > + msa_misc = 2 * val[0] + 32 * val[1] + > + ((video->color_fmt == Y_ONLY) ? (1 << 14) : 0); > + > + return msa_misc; > +} > + > +int cdn_dp_config_video(struct cdn_dp_device *dp) > +{ > + struct video_info *video = &dp->video_info; > + struct drm_display_mode *mode = &dp->mode; > + u64 symbol, tmp; > + u32 val, link_rate; > + u8 bit_per_pix, tu_size_reg = TU_SIZE; > + int ret; > + > + bit_per_pix = (video->color_fmt == YCBCR_4_2_2) ? > + (video->color_depth * 2) : (video->color_depth * 3); > + > + link_rate = drm_dp_bw_code_to_link_rate(dp->link.rate) / 1000; > + > + val = VIF_BYPASS_INTERLACE; > + ret = cdn_dp_reg_write(dp, BND_HSYNC2VSYNC, val); > + if (ret) > + goto err_config_video; > + > + ret = cdn_dp_reg_write(dp, HSYNC2VSYNC_POL_CTRL, 0); > + if (ret) > + goto err_config_video; > + > + /* > + * get a best tu_size and valid symbol: > + * 1. chose Lclk freq(162Mhz, 270Mhz, 540Mhz), set TU to 32 > + * 2. calculate VS(valid symbol) = TU * Pclk * Bpp / (Lclk * Lanes) > + * 3. if VS > *.85 or VS < *.1 or VS < 2 or TU < VS + 4, then set > + * TU += 2 and repeat 2nd step. > + */ > + do { > + tu_size_reg += 2; > + tmp = tu_size_reg * mode->clock * bit_per_pix; > + tmp /= dp->link.num_lanes * link_rate * 8; > + symbol = tmp / 1000; > + } while ((symbol <= 1) || (tu_size_reg - symbol < 4) || > + (tmp % 1000 > 850) || (tmp % 1000 < 100)); > + > + val = symbol + (tu_size_reg << 8); > + ret = cdn_dp_reg_write(dp, DP_FRAMER_TU, val); > + if (ret) > + goto err_config_video; > + > + /* set the FIFO Buffer size */ > + val = ((mode->clock * (symbol + 1) / 1000) + link_rate); > + val /= (dp->link.num_lanes * link_rate); > + val = 8 * (symbol + 1) / bit_per_pix - val; > + val += 2; > + ret = cdn_dp_reg_write(dp, DP_VC_TABLE(15), val); > + > + switch (video->color_depth) { > + case 6: > + val = BCS_6; > + break; > + case 8: > + val = BCS_8; > + break; > + case 10: > + val = BCS_10; > + break; > + case 12: > + val = BCS_12; > + break; > + case 16: > + val = BCS_16; > + break; > + }; > + > + val += video->color_fmt << 8; > + ret = cdn_dp_reg_write(dp, DP_FRAMER_PXL_REPR, val); > + if (ret) > + goto err_config_video; > + > + val = video->h_sync_polarity ? DP_FRAMER_SP_HSP : 0; > + val |= video->v_sync_polarity ? DP_FRAMER_SP_VSP : 0; > + ret = cdn_dp_reg_write(dp, DP_FRAMER_SP, val); > + if (ret) > + goto err_config_video; > + > + val = (mode->hsync_start - mode->hdisplay) << 16; > + val |= mode->htotal - mode->hsync_end; > + ret = cdn_dp_reg_write(dp, DP_FRONT_BACK_PORCH, val); > + if (ret) > + goto err_config_video; > + > + val = mode->hdisplay * bit_per_pix / 8; > + ret = cdn_dp_reg_write(dp, DP_BYTE_COUNT, val); > + if (ret) > + goto err_config_video; > + > + val = mode->htotal | ((mode->htotal - mode->hsync_start) << 16); > + ret = cdn_dp_reg_write(dp, MSA_HORIZONTAL_0, val); > + if (ret) > + goto err_config_video; > + > + val = mode->hsync_end - mode->hsync_start; > + val |= (mode->hdisplay << 16) | (video->h_sync_polarity << 15); > + ret = cdn_dp_reg_write(dp, MSA_HORIZONTAL_1, val); > + if (ret) > + goto err_config_video; > + > + val = mode->vtotal; > + val |= ((mode->vtotal - mode->vsync_start) << 16); > + ret = cdn_dp_reg_write(dp, MSA_VERTICAL_0, val); > + if (ret) > + goto err_config_video; > + > + val = mode->vsync_end - mode->vsync_start; > + val |= mode->vdisplay << 16 | (video->v_sync_polarity << 15); > + ret = cdn_dp_reg_write(dp, MSA_VERTICAL_1, val); > + if (ret) > + goto err_config_video; > + > + val = cdn_dp_get_msa_misc(video, mode); > + ret = cdn_dp_reg_write(dp, MSA_MISC, val); > + if (ret) > + goto err_config_video; > + > + ret = cdn_dp_reg_write(dp, STREAM_CONFIG, 1); > + if (ret) > + goto err_config_video; > + > + val = mode->hsync_end - mode->hsync_start; > + val |= (mode->hdisplay << 16); > + ret = cdn_dp_reg_write(dp, DP_HORIZONTAL, val); > + if (ret) > + goto err_config_video; > + > + val = mode->vtotal; > + val -= (mode->vtotal - mode->vdisplay); > + val |= (mode->vtotal - mode->vsync_start) << 16; > + ret = cdn_dp_reg_write(dp, DP_VERTICAL_0, val); > + if (ret) > + goto err_config_video; > + > + val = mode->vtotal; > + ret = cdn_dp_reg_write(dp, DP_VERTICAL_1, val); > + if (ret) > + goto err_config_video; > + > + val = 0; > + ret = cdn_dp_reg_write_bit(dp, DP_VB_ID, 2, 1, val); > + > +err_config_video: > + if (ret) > + dev_err(dp->dev, "config video failed: %d\n", ret); > + return ret; > +} > + > +int cdn_dp_audio_stop(struct cdn_dp_device *dp, struct audio_info *audio) > +{ > + u32 val; > + int ret; > + > + ret = cdn_dp_reg_write(dp, AUDIO_PACK_CONTROL, 0); > + if (ret) { > + dev_err(dp->dev, "audio stop failed: %d\n", ret); > + return ret; > + } > + > + val = SPDIF_AVG_SEL | SPDIF_JITTER_BYPASS; > + val |= SPDIF_FIFO_MID_RANGE(0xe0); > + val |= SPDIF_JITTER_THRSH(0xe0); > + val |= SPDIF_JITTER_AVG_WIN(7); > + writel(val, dp->regs + SPDIF_CTRL_ADDR); > + > + /* clearn the audio config and reset */ > + writel(0, dp->regs + AUDIO_SRC_CNTL); > + writel(0, dp->regs + AUDIO_SRC_CNFG); > + writel(AUDIO_SW_RST, dp->regs + AUDIO_SRC_CNTL); > + writel(0, dp->regs + AUDIO_SRC_CNTL); > + > + /* reset smpl2pckt component */ > + writel(0, dp->regs + SMPL2PKT_CNTL); > + writel(AUDIO_SW_RST, dp->regs + SMPL2PKT_CNTL); > + writel(0, dp->regs + SMPL2PKT_CNTL); > + > + /* reset FIFO */ > + writel(AUDIO_SW_RST, dp->regs + FIFO_CNTL); > + writel(0, dp->regs + FIFO_CNTL); > + > + if (audio->format == AFMT_SPDIF) > + clk_disable_unprepare(dp->spdif_clk); > + > + return 0; > +} > + > +int cdn_dp_audio_mute(struct cdn_dp_device *dp, bool enable) > +{ > + int ret; > + > + ret = cdn_dp_reg_write_bit(dp, DP_VB_ID, 4, 1, enable); > + if (ret) > + dev_err(dp->dev, "audio mute failed: %d\n", ret); > + > + return ret; > +} > + > +static void cdn_dp_audio_config_i2s(struct cdn_dp_device *dp, > + struct audio_info *audio) > +{ > + int sub_pckt_num = 1, i2s_port_en_val = 0xf, i; > + u32 val; > + > + if (audio->channels == 2) { > + if (dp->link.num_lanes == 1) > + sub_pckt_num = 2; > + else > + sub_pckt_num = 4; > + > + i2s_port_en_val = 1; > + } else if (audio->channels == 4) { > + i2s_port_en_val = 3; > + } > + > + writel(0x0, dp->regs + SPDIF_CTRL_ADDR); > + > + writel(SYNC_WR_TO_CH_ZERO, dp->regs + FIFO_CNTL); > + > + val = MAX_NUM_CH(audio->channels); > + val |= NUM_OF_I2S_PORTS(audio->channels); > + val |= AUDIO_TYPE_LPCM; > + val |= CFG_SUB_PCKT_NUM(sub_pckt_num); > + writel(val, dp->regs + SMPL2PKT_CNFG); > + > + if (audio->sample_width == 16) > + val = 0; > + else if (audio->sample_width == 24) > + val = 1 << 9; > + else > + val = 2 << 9; > + > + val |= AUDIO_CH_NUM(audio->channels); > + val |= I2S_DEC_PORT_EN(i2s_port_en_val); > + val |= TRANS_SMPL_WIDTH_32; > + writel(val, dp->regs + AUDIO_SRC_CNFG); > + > + for (i = 0; i < (audio->channels + 1) / 2; i++) { > + if (audio->sample_width == 16) > + val = (0x08 << 8) | (0x08 << 20); > + else if (audio->sample_width == 24) > + val = (0x0b << 8) | (0x0b << 20); > + > + val |= ((2 * i) << 4) | ((2 * i + 1) << 16); > + writel(val, dp->regs + STTS_BIT_CH(i)); > + } > + > + switch (audio->sample_rate) { > + case 32000: > + val = SAMPLING_FREQ(3) | > + ORIGINAL_SAMP_FREQ(0xc); > + break; > + case 44100: > + val = SAMPLING_FREQ(0) | > + ORIGINAL_SAMP_FREQ(0xf); > + break; > + case 48000: > + val = SAMPLING_FREQ(2) | > + ORIGINAL_SAMP_FREQ(0xd); > + break; > + case 88200: > + val = SAMPLING_FREQ(8) | > + ORIGINAL_SAMP_FREQ(0x7); > + break; > + case 96000: > + val = SAMPLING_FREQ(0xa) | > + ORIGINAL_SAMP_FREQ(5); > + break; > + case 176400: > + val = SAMPLING_FREQ(0xc) | > + ORIGINAL_SAMP_FREQ(3); > + break; > + case 192000: > + val = SAMPLING_FREQ(0xe) | > + ORIGINAL_SAMP_FREQ(1); > + break; > + } > + val |= 4; > + writel(val, dp->regs + COM_CH_STTS_BITS); > + > + writel(SMPL2PKT_EN, dp->regs + SMPL2PKT_CNTL); > + writel(I2S_DEC_START, dp->regs + AUDIO_SRC_CNTL); > +} > + > +static void cdn_dp_audio_config_spdif(struct cdn_dp_device *dp) > +{ > + u32 val; > + > + val = SPDIF_AVG_SEL | SPDIF_JITTER_BYPASS; > + val |= SPDIF_FIFO_MID_RANGE(0xe0); > + val |= SPDIF_JITTER_THRSH(0xe0); > + val |= SPDIF_JITTER_AVG_WIN(7); > + writel(val, dp->regs + SPDIF_CTRL_ADDR); > + > + writel(SYNC_WR_TO_CH_ZERO, dp->regs + FIFO_CNTL); > + > + val = MAX_NUM_CH(2) | AUDIO_TYPE_LPCM | CFG_SUB_PCKT_NUM(4); > + writel(val, dp->regs + SMPL2PKT_CNFG); > + writel(SMPL2PKT_EN, dp->regs + SMPL2PKT_CNTL); > + > + val = SPDIF_ENABLE | SPDIF_AVG_SEL | SPDIF_JITTER_BYPASS; > + val |= SPDIF_FIFO_MID_RANGE(0xe0); > + val |= SPDIF_JITTER_THRSH(0xe0); > + val |= SPDIF_JITTER_AVG_WIN(7); > + writel(val, dp->regs + SPDIF_CTRL_ADDR); > + > + clk_prepare_enable(dp->spdif_clk); > + clk_set_rate(dp->spdif_clk, CDN_DP_SPDIF_CLK); > +} > + > +int cdn_dp_audio_config(struct cdn_dp_device *dp, struct audio_info *audio) > +{ > + int ret; > + > + /* reset the spdif clk before config */ > + if (audio->format == AFMT_SPDIF) { > + reset_control_assert(dp->spdif_rst); > + reset_control_deassert(dp->spdif_rst); > + } > + > + ret = cdn_dp_reg_write(dp, CM_LANE_CTRL, LANE_REF_CYC); > + if (ret) > + goto err_audio_config; > + > + ret = cdn_dp_reg_write(dp, CM_CTRL, 0); > + if (ret) > + goto err_audio_config; > + > + if (audio->format == AFMT_I2S) > + cdn_dp_audio_config_i2s(dp, audio); > + else > + cdn_dp_audio_config_spdif(dp); > + > + ret = cdn_dp_reg_write(dp, AUDIO_PACK_CONTROL, AUDIO_PACK_EN); > + > +err_audio_config: > + if (ret) > + dev_err(dp->dev, "audio config failed: %d\n", ret); > + return ret; > +} > diff --git a/drivers/gpu/drm/rockchip/cdn-dp-reg.h b/drivers/gpu/drm/rockchip/cdn-dp-reg.h > new file mode 100644 > index 0000000..6ac3674 > --- /dev/null > +++ b/drivers/gpu/drm/rockchip/cdn-dp-reg.h > @@ -0,0 +1,482 @@ > +/* > + * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd > + * Author: Chris Zhong > + * > + * This software is licensed under the terms of the GNU General Public > + * License version 2, as published by the Free Software Foundation, and > + * may be copied, distributed, and modified under those terms. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + */ > + > +#ifndef _CDN_DP_REG_H > +#define _CDN_DP_REG_H > + > +#include > + > +#define ADDR_IMEM 0x10000 > +#define ADDR_DMEM 0x20000 > + > +/* APB CFG addr */ > +#define APB_CTRL 0 > +#define XT_INT_CTRL 0x04 > +#define MAILBOX_FULL_ADDR 0x08 > +#define MAILBOX_EMPTY_ADDR 0x0c > +#define MAILBOX0_WR_DATA 0x10 > +#define MAILBOX0_RD_DATA 0x14 > +#define KEEP_ALIVE 0x18 > +#define VER_L 0x1c > +#define VER_H 0x20 > +#define VER_LIB_L_ADDR 0x24 > +#define VER_LIB_H_ADDR 0x28 > +#define SW_DEBUG_L 0x2c > +#define SW_DEBUG_H 0x30 > +#define MAILBOX_INT_MASK 0x34 > +#define MAILBOX_INT_STATUS 0x38 > +#define SW_CLK_L 0x3c > +#define SW_CLK_H 0x40 > +#define SW_EVENTS0 0x44 > +#define SW_EVENTS1 0x48 > +#define SW_EVENTS2 0x4c > +#define SW_EVENTS3 0x50 > +#define XT_OCD_CTRL 0x60 > +#define APB_INT_MASK 0x6c > +#define APB_STATUS_MASK 0x70 > + > +/* audio decoder addr */ > +#define AUDIO_SRC_CNTL 0x30000 > +#define AUDIO_SRC_CNFG 0x30004 > +#define COM_CH_STTS_BITS 0x30008 > +#define STTS_BIT_CH(x) (0x3000c + ((x) << 2)) > +#define SPDIF_CTRL_ADDR 0x3004c > +#define SPDIF_CH1_CS_3100_ADDR 0x30050 > +#define SPDIF_CH1_CS_6332_ADDR 0x30054 > +#define SPDIF_CH1_CS_9564_ADDR 0x30058 > +#define SPDIF_CH1_CS_12796_ADDR 0x3005c > +#define SPDIF_CH1_CS_159128_ADDR 0x30060 > +#define SPDIF_CH1_CS_191160_ADDR 0x30064 > +#define SPDIF_CH2_CS_3100_ADDR 0x30068 > +#define SPDIF_CH2_CS_6332_ADDR 0x3006c > +#define SPDIF_CH2_CS_9564_ADDR 0x30070 > +#define SPDIF_CH2_CS_12796_ADDR 0x30074 > +#define SPDIF_CH2_CS_159128_ADDR 0x30078 > +#define SPDIF_CH2_CS_191160_ADDR 0x3007c > +#define SMPL2PKT_CNTL 0x30080 > +#define SMPL2PKT_CNFG 0x30084 > +#define FIFO_CNTL 0x30088 > +#define FIFO_STTS 0x3008c > + > +/* source pif addr */ > +#define SOURCE_PIF_WR_ADDR 0x30800 > +#define SOURCE_PIF_WR_REQ 0x30804 > +#define SOURCE_PIF_RD_ADDR 0x30808 > +#define SOURCE_PIF_RD_REQ 0x3080c > +#define SOURCE_PIF_DATA_WR 0x30810 > +#define SOURCE_PIF_DATA_RD 0x30814 > +#define SOURCE_PIF_FIFO1_FLUSH 0x30818 > +#define SOURCE_PIF_FIFO2_FLUSH 0x3081c > +#define SOURCE_PIF_STATUS 0x30820 > +#define SOURCE_PIF_INTERRUPT_SOURCE 0x30824 > +#define SOURCE_PIF_INTERRUPT_MASK 0x30828 > +#define SOURCE_PIF_PKT_ALLOC_REG 0x3082c > +#define SOURCE_PIF_PKT_ALLOC_WR_EN 0x30830 > +#define SOURCE_PIF_SW_RESET 0x30834 > + > +/* bellow registers need access by mailbox */ > +/* source car addr */ > +#define SOURCE_HDTX_CAR 0x0900 > +#define SOURCE_DPTX_CAR 0x0904 > +#define SOURCE_PHY_CAR 0x0908 > +#define SOURCE_CEC_CAR 0x090c > +#define SOURCE_CBUS_CAR 0x0910 > +#define SOURCE_PKT_CAR 0x0918 > +#define SOURCE_AIF_CAR 0x091c > +#define SOURCE_CIPHER_CAR 0x0920 > +#define SOURCE_CRYPTO_CAR 0x0924 > + > +/* clock meters addr */ > +#define CM_CTRL 0x0a00 > +#define CM_I2S_CTRL 0x0a04 > +#define CM_SPDIF_CTRL 0x0a08 > +#define CM_VID_CTRL 0x0a0c > +#define CM_LANE_CTRL 0x0a10 > +#define I2S_NM_STABLE 0x0a14 > +#define I2S_NCTS_STABLE 0x0a18 > +#define SPDIF_NM_STABLE 0x0a1c > +#define SPDIF_NCTS_STABLE 0x0a20 > +#define NMVID_MEAS_STABLE 0x0a24 > +#define I2S_MEAS 0x0a40 > +#define SPDIF_MEAS 0x0a80 > +#define NMVID_MEAS 0x0ac0 > + > +/* source vif addr */ > +#define BND_HSYNC2VSYNC 0x0b00 > +#define HSYNC2VSYNC_F1_L1 0x0b04 > +#define HSYNC2VSYNC_F2_L1 0x0b08 > +#define HSYNC2VSYNC_STATUS 0x0b0c > +#define HSYNC2VSYNC_POL_CTRL 0x0b10 > + > +/* dptx phy addr */ > +#define DP_TX_PHY_CONFIG_REG 0x2000 > +#define DP_TX_PHY_STATUS_REG 0x2004 > +#define DP_TX_PHY_SW_RESET 0x2008 > +#define DP_TX_PHY_SCRAMBLER_SEED 0x200c > +#define DP_TX_PHY_TRAINING_01_04 0x2010 > +#define DP_TX_PHY_TRAINING_05_08 0x2014 > +#define DP_TX_PHY_TRAINING_09_10 0x2018 > +#define TEST_COR 0x23fc > + > +/* dptx hpd addr */ > +#define HPD_IRQ_DET_MIN_TIMER 0x2100 > +#define HPD_IRQ_DET_MAX_TIMER 0x2104 > +#define HPD_UNPLGED_DET_MIN_TIMER 0x2108 > +#define HPD_STABLE_TIMER 0x210c > +#define HPD_FILTER_TIMER 0x2110 > +#define HPD_EVENT_MASK 0x211c > +#define HPD_EVENT_DET 0x2120 > + > +/* dpyx framer addr */ > +#define DP_FRAMER_GLOBAL_CONFIG 0x2200 > +#define DP_SW_RESET 0x2204 > +#define DP_FRAMER_TU 0x2208 > +#define DP_FRAMER_PXL_REPR 0x220c > +#define DP_FRAMER_SP 0x2210 > +#define AUDIO_PACK_CONTROL 0x2214 > +#define DP_VC_TABLE(x) (0x2218 + ((x) << 2)) > +#define DP_VB_ID 0x2258 > +#define DP_MTPH_LVP_CONTROL 0x225c > +#define DP_MTPH_SYMBOL_VALUES 0x2260 > +#define DP_MTPH_ECF_CONTROL 0x2264 > +#define DP_MTPH_ACT_CONTROL 0x2268 > +#define DP_MTPH_STATUS 0x226c > +#define DP_INTERRUPT_SOURCE 0x2270 > +#define DP_INTERRUPT_MASK 0x2274 > +#define DP_FRONT_BACK_PORCH 0x2278 > +#define DP_BYTE_COUNT 0x227c > + > +/* dptx stream addr */ > +#define MSA_HORIZONTAL_0 0x2280 > +#define MSA_HORIZONTAL_1 0x2284 > +#define MSA_VERTICAL_0 0x2288 > +#define MSA_VERTICAL_1 0x228c > +#define MSA_MISC 0x2290 > +#define STREAM_CONFIG 0x2294 > +#define AUDIO_PACK_STATUS 0x2298 > +#define VIF_STATUS 0x229c > +#define PCK_STUFF_STATUS_0 0x22a0 > +#define PCK_STUFF_STATUS_1 0x22a4 > +#define INFO_PACK_STATUS 0x22a8 > +#define RATE_GOVERNOR_STATUS 0x22ac > +#define DP_HORIZONTAL 0x22b0 > +#define DP_VERTICAL_0 0x22b4 > +#define DP_VERTICAL_1 0x22b8 > +#define DP_BLOCK_SDP 0x22bc > + > +/* dptx glbl addr */ > +#define DPTX_LANE_EN 0x2300 > +#define DPTX_ENHNCD 0x2304 > +#define DPTX_INT_MASK 0x2308 > +#define DPTX_INT_STATUS 0x230c > + > +/* dp aux addr */ > +#define DP_AUX_HOST_CONTROL 0x2800 > +#define DP_AUX_INTERRUPT_SOURCE 0x2804 > +#define DP_AUX_INTERRUPT_MASK 0x2808 > +#define DP_AUX_SWAP_INVERSION_CONTROL 0x280c > +#define DP_AUX_SEND_NACK_TRANSACTION 0x2810 > +#define DP_AUX_CLEAR_RX 0x2814 > +#define DP_AUX_CLEAR_TX 0x2818 > +#define DP_AUX_TIMER_STOP 0x281c > +#define DP_AUX_TIMER_CLEAR 0x2820 > +#define DP_AUX_RESET_SW 0x2824 > +#define DP_AUX_DIVIDE_2M 0x2828 > +#define DP_AUX_TX_PREACHARGE_LENGTH 0x282c > +#define DP_AUX_FREQUENCY_1M_MAX 0x2830 > +#define DP_AUX_FREQUENCY_1M_MIN 0x2834 > +#define DP_AUX_RX_PRE_MIN 0x2838 > +#define DP_AUX_RX_PRE_MAX 0x283c > +#define DP_AUX_TIMER_PRESET 0x2840 > +#define DP_AUX_NACK_FORMAT 0x2844 > +#define DP_AUX_TX_DATA 0x2848 > +#define DP_AUX_RX_DATA 0x284c > +#define DP_AUX_TX_STATUS 0x2850 > +#define DP_AUX_RX_STATUS 0x2854 > +#define DP_AUX_RX_CYCLE_COUNTER 0x2858 > +#define DP_AUX_MAIN_STATES 0x285c > +#define DP_AUX_MAIN_TIMER 0x2860 > +#define DP_AUX_AFE_OUT 0x2864 > + > +/* crypto addr */ > +#define CRYPTO_HDCP_REVISION 0x5800 > +#define HDCP_CRYPTO_CONFIG 0x5804 > +#define CRYPTO_INTERRUPT_SOURCE 0x5808 > +#define CRYPTO_INTERRUPT_MASK 0x580c > +#define CRYPTO22_CONFIG 0x5818 > +#define CRYPTO22_STATUS 0x581c > +#define SHA_256_DATA_IN 0x583c > +#define SHA_256_DATA_OUT_(x) (0x5850 + ((x) << 2)) > +#define AES_32_KEY_(x) (0x5870 + ((x) << 2)) > +#define AES_32_DATA_IN 0x5880 > +#define AES_32_DATA_OUT_(x) (0x5884 + ((x) << 2)) > +#define CRYPTO14_CONFIG 0x58a0 > +#define CRYPTO14_STATUS 0x58a4 > +#define CRYPTO14_PRNM_OUT 0x58a8 > +#define CRYPTO14_KM_0 0x58ac > +#define CRYPTO14_KM_1 0x58b0 > +#define CRYPTO14_AN_0 0x58b4 > +#define CRYPTO14_AN_1 0x58b8 > +#define CRYPTO14_YOUR_KSV_0 0x58bc > +#define CRYPTO14_YOUR_KSV_1 0x58c0 > +#define CRYPTO14_MI_0 0x58c4 > +#define CRYPTO14_MI_1 0x58c8 > +#define CRYPTO14_TI_0 0x58cc > +#define CRYPTO14_KI_0 0x58d0 > +#define CRYPTO14_KI_1 0x58d4 > +#define CRYPTO14_BLOCKS_NUM 0x58d8 > +#define CRYPTO14_KEY_MEM_DATA_0 0x58dc > +#define CRYPTO14_KEY_MEM_DATA_1 0x58e0 > +#define CRYPTO14_SHA1_MSG_DATA 0x58e4 > +#define CRYPTO14_SHA1_V_VALUE_(x) (0x58e8 + ((x) << 2)) > +#define TRNG_CTRL 0x58fc > +#define TRNG_DATA_RDY 0x5900 > +#define TRNG_DATA 0x5904 > + > +/* cipher addr */ > +#define HDCP_REVISION 0x60000 > +#define INTERRUPT_SOURCE 0x60004 > +#define INTERRUPT_MASK 0x60008 > +#define HDCP_CIPHER_CONFIG 0x6000c > +#define AES_128_KEY_0 0x60010 > +#define AES_128_KEY_1 0x60014 > +#define AES_128_KEY_2 0x60018 > +#define AES_128_KEY_3 0x6001c > +#define AES_128_RANDOM_0 0x60020 > +#define AES_128_RANDOM_1 0x60024 > +#define CIPHER14_KM_0 0x60028 > +#define CIPHER14_KM_1 0x6002c > +#define CIPHER14_STATUS 0x60030 > +#define CIPHER14_RI_PJ_STATUS 0x60034 > +#define CIPHER_MODE 0x60038 > +#define CIPHER14_AN_0 0x6003c > +#define CIPHER14_AN_1 0x60040 > +#define CIPHER22_AUTH 0x60044 > +#define CIPHER14_R0_DP_STATUS 0x60048 > +#define CIPHER14_BOOTSTRAP 0x6004c > + > +#define DPTX_FRMR_DATA_CLK_RSTN_EN BIT(11) > +#define DPTX_FRMR_DATA_CLK_EN BIT(10) > +#define DPTX_PHY_DATA_RSTN_EN BIT(9) > +#define DPTX_PHY_DATA_CLK_EN BIT(8) > +#define DPTX_PHY_CHAR_RSTN_EN BIT(7) > +#define DPTX_PHY_CHAR_CLK_EN BIT(6) > +#define SOURCE_AUX_SYS_CLK_RSTN_EN BIT(5) > +#define SOURCE_AUX_SYS_CLK_EN BIT(4) > +#define DPTX_SYS_CLK_RSTN_EN BIT(3) > +#define DPTX_SYS_CLK_EN BIT(2) > +#define CFG_DPTX_VIF_CLK_RSTN_EN BIT(1) > +#define CFG_DPTX_VIF_CLK_EN BIT(0) > + > +#define SOURCE_PHY_RSTN_EN BIT(1) > +#define SOURCE_PHY_CLK_EN BIT(0) > + > +#define SOURCE_PKT_SYS_RSTN_EN BIT(3) > +#define SOURCE_PKT_SYS_CLK_EN BIT(2) > +#define SOURCE_PKT_DATA_RSTN_EN BIT(1) > +#define SOURCE_PKT_DATA_CLK_EN BIT(0) > + > +#define SPDIF_CDR_CLK_RSTN_EN BIT(5) > +#define SPDIF_CDR_CLK_EN BIT(4) > +#define SOURCE_AIF_SYS_RSTN_EN BIT(3) > +#define SOURCE_AIF_SYS_CLK_EN BIT(2) > +#define SOURCE_AIF_CLK_RSTN_EN BIT(1) > +#define SOURCE_AIF_CLK_EN BIT(0) > + > +#define SOURCE_CIPHER_SYSTEM_CLK_RSTN_EN BIT(3) > +#define SOURCE_CIPHER_SYS_CLK_EN BIT(2) > +#define SOURCE_CIPHER_CHAR_CLK_RSTN_EN BIT(1) > +#define SOURCE_CIPHER_CHAR_CLK_EN BIT(0) > + > +#define SOURCE_CRYPTO_SYS_CLK_RSTN_EN BIT(1) > +#define SOURCE_CRYPTO_SYS_CLK_EN BIT(0) > + > +#define APB_IRAM_PATH BIT(2) > +#define APB_DRAM_PATH BIT(1) > +#define APB_XT_RESET BIT(0) > + > +#define MAILBOX_INT_MASK_BIT BIT(1) > +#define PIF_INT_MASK_BIT BIT(0) > +#define ALL_INT_MASK 3 > + > +/* mailbox */ > +#define MB_OPCODE_ID 0 > +#define MB_MODULE_ID 1 > +#define MB_SIZE_MSB_ID 2 > +#define MB_SIZE_LSB_ID 3 > +#define MB_DATA_ID 4 > + > +#define MB_MODULE_ID_DP_TX 0x01 > +#define MB_MODULE_ID_HDCP_TX 0x07 > +#define MB_MODULE_ID_HDCP_RX 0x08 > +#define MB_MODULE_ID_HDCP_GENERAL 0x09 > +#define MB_MODULE_ID_GENERAL 0x0a > + > +/* general opcode */ > +#define GENERAL_MAIN_CONTROL 0x01 > +#define GENERAL_TEST_ECHO 0x02 > +#define GENERAL_BUS_SETTINGS 0x03 > +#define GENERAL_TEST_ACCESS 0x04 > + > +#define DPTX_SET_POWER_MNG 0x00 > +#define DPTX_SET_HOST_CAPABILITIES 0x01 > +#define DPTX_GET_EDID 0x02 > +#define DPTX_READ_DPCD 0x03 > +#define DPTX_WRITE_DPCD 0x04 > +#define DPTX_ENABLE_EVENT 0x05 > +#define DPTX_WRITE_REGISTER 0x06 > +#define DPTX_READ_REGISTER 0x07 > +#define DPTX_WRITE_FIELD 0x08 > +#define DPTX_TRAINING_CONTROL 0x09 > +#define DPTX_READ_EVENT 0x0a > +#define DPTX_READ_LINK_STAT 0x0b > +#define DPTX_SET_VIDEO 0x0c > +#define DPTX_SET_AUDIO 0x0d > +#define DPTX_GET_LAST_AUX_STAUS 0x0e > +#define DPTX_SET_LINK_BREAK_POINT 0x0f > +#define DPTX_FORCE_LANES 0x10 > +#define DPTX_HPD_STATE 0x11 > + > +#define FW_STANDBY 0 > +#define FW_ACTIVE 1 > + > +#define DPTX_EVENT_ENABLE_HPD BIT(0) > +#define DPTX_EVENT_ENABLE_TRAINING BIT(1) > + > +#define LINK_TRAINING_NOT_ACTIVE 0 > +#define LINK_TRAINING_RUN 1 > +#define LINK_TRAINING_RESTART 2 > + > +#define CONTROL_VIDEO_IDLE 0 > +#define CONTROL_VIDEO_VALID 1 > + > +#define VIF_BYPASS_INTERLACE BIT(13) > +#define INTERLACE_FMT_DET BIT(12) > +#define INTERLACE_DTCT_WIN 0x20 > + > +#define DP_FRAMER_SP_INTERLACE_EN BIT(2) > +#define DP_FRAMER_SP_HSP BIT(1) > +#define DP_FRAMER_SP_VSP BIT(0) > + > +/* capability */ > +#define AUX_HOST_INVERT 3 > +#define FAST_LT_SUPPORT 1 > +#define FAST_LT_NOT_SUPPORT 0 > +#define LANE_MAPPING_NORMAL 0x1b > +#define LANE_MAPPING_FLIPPED 0xe4 > +#define ENHANCED 1 > + > +#define FULL_LT_STARTED BIT(0) > +#define FASE_LT_STARTED BIT(1) > +#define CLK_RECOVERY_FINISHED BIT(2) > +#define EQ_PHASE_FINISHED BIT(3) > +#define FASE_LT_START_FINISHED BIT(4) > +#define CLK_RECOVERY_FAILED BIT(5) > +#define EQ_PHASE_FAILED BIT(6) > +#define FASE_LT_FAILED BIT(7) > + > +#define DPTX_HPD_EVENT BIT(0) > +#define DPTX_TRAINING_EVENT BIT(1) > +#define HDCP_TX_STATUS_EVENT BIT(4) > +#define HDCP2_TX_IS_KM_STORED_EVENT BIT(5) > +#define HDCP2_TX_STORE_KM_EVENT BIT(6) > +#define HDCP_TX_IS_RECEIVER_ID_VALID_EVENT BIT(7) > + > +#define TU_SIZE 30 > +#define CDN_DP_MAX_LINK_RATE DP_LINK_BW_5_4 > + > +/* audio */ > +#define AUDIO_PACK_EN BIT(8) > +#define SAMPLING_FREQ(x) (((x) & 0xf) << 16) > +#define ORIGINAL_SAMP_FREQ(x) (((x) & 0xf) << 24) > +#define SYNC_WR_TO_CH_ZERO BIT(1) > +#define I2S_DEC_START BIT(1) > +#define AUDIO_SW_RST BIT(0) > +#define SMPL2PKT_EN BIT(1) > +#define MAX_NUM_CH(x) (((x) & 0x1f) - 1) > +#define NUM_OF_I2S_PORTS(x) ((((x) / 2 - 1) & 0x3) << 5) > +#define AUDIO_TYPE_LPCM (2 << 7) > +#define CFG_SUB_PCKT_NUM(x) ((((x) - 1) & 0x7) << 11) > +#define AUDIO_CH_NUM(x) ((((x) - 1) & 0x1f) << 2) > +#define TRANS_SMPL_WIDTH_16 0 > +#define TRANS_SMPL_WIDTH_24 BIT(11) > +#define TRANS_SMPL_WIDTH_32 (2 << 11) > +#define I2S_DEC_PORT_EN(x) (((x) & 0xf) << 17) > +#define SPDIF_ENABLE BIT(21) > +#define SPDIF_AVG_SEL BIT(20) > +#define SPDIF_JITTER_BYPASS BIT(19) > +#define SPDIF_FIFO_MID_RANGE(x) (((x) & 0xff) << 11) > +#define SPDIF_JITTER_THRSH(x) (((x) & 0xff) << 3) > +#define SPDIF_JITTER_AVG_WIN(x) ((x) & 0x7) > + > +/* Refernce cycles when using lane clock as refernce */ > +#define LANE_REF_CYC 0x8000 > + > +enum voltage_swing_level { > + VOLTAGE_LEVEL_0, > + VOLTAGE_LEVEL_1, > + VOLTAGE_LEVEL_2, > + VOLTAGE_LEVEL_3, > +}; > + > +enum pre_emphasis_level { > + PRE_EMPHASIS_LEVEL_0, > + PRE_EMPHASIS_LEVEL_1, > + PRE_EMPHASIS_LEVEL_2, > + PRE_EMPHASIS_LEVEL_3, > +}; > + > +enum pattern_set { > + PTS1 = BIT(0), > + PTS2 = BIT(1), > + PTS3 = BIT(2), > + PTS4 = BIT(3), > + DP_NONE = BIT(4) > +}; > + > +enum vic_color_depth { > + BCS_6 = 0x1, > + BCS_8 = 0x2, > + BCS_10 = 0x4, > + BCS_12 = 0x8, > + BCS_16 = 0x10, > +}; > + > +enum vic_bt_type { > + BT_601 = 0x0, > + BT_709 = 0x1, > +}; > + > +void cdn_dp_clock_reset(struct cdn_dp_device *dp); > + > +void cdn_dp_set_fw_clk(struct cdn_dp_device *dp, u32 clk); > +int cdn_dp_load_firmware(struct cdn_dp_device *dp, const u32 *i_mem, > + u32 i_size, const u32 *d_mem, u32 d_size); > +int cdn_dp_set_firmware_active(struct cdn_dp_device *dp, bool enable); > +int cdn_dp_set_host_cap(struct cdn_dp_device *dp, u8 lanes, bool flip); > +int cdn_dp_event_config(struct cdn_dp_device *dp); > +u32 cdn_dp_get_event(struct cdn_dp_device *dp); > +int cdn_dp_get_hpd_status(struct cdn_dp_device *dp); > +int cdn_dp_dpcd_write(struct cdn_dp_device *dp, u32 addr, u8 value); > +int cdn_dp_dpcd_read(struct cdn_dp_device *dp, u32 addr, u8 *data, u16 len); > +int cdn_dp_get_edid_block(void *dp, u8 *edid, > + unsigned int block, size_t length); > +int cdn_dp_training_start(struct cdn_dp_device *dp); > +int cdn_dp_get_training_status(struct cdn_dp_device *dp); > +int cdn_dp_set_video_status(struct cdn_dp_device *dp, int active); > +int cdn_dp_config_video(struct cdn_dp_device *dp); > +int cdn_dp_audio_stop(struct cdn_dp_device *dp, struct audio_info *audio); > +int cdn_dp_audio_mute(struct cdn_dp_device *dp, bool enable); > +int cdn_dp_audio_config(struct cdn_dp_device *dp, struct audio_info *audio); > +#endif /* _CDN_DP_REG_H */ > diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c > index edd7ec2..d723d8e 100644 > --- a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c > +++ b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c > @@ -969,9 +969,11 @@ static void vop_crtc_enable(struct drm_crtc *crtc) > vop_dsp_hold_valid_irq_disable(vop); > } > > - pin_pol = 0x8; > - pin_pol |= (adjusted_mode->flags & DRM_MODE_FLAG_NHSYNC) ? 0 : 1; > - pin_pol |= (adjusted_mode->flags & DRM_MODE_FLAG_NVSYNC) ? 0 : (1 << 1); > + pin_pol = BIT(DCLK_INVERT); > + pin_pol |= (adjusted_mode->flags & DRM_MODE_FLAG_NHSYNC) ? > + 0 : BIT(HSYNC_POSITIVE); > + pin_pol |= (adjusted_mode->flags & DRM_MODE_FLAG_NVSYNC) ? > + 0 : BIT(VSYNC_POSITIVE); > VOP_CTRL_SET(vop, pin_pol, pin_pol); > > switch (s->output_type) { > @@ -991,6 +993,11 @@ static void vop_crtc_enable(struct drm_crtc *crtc) > VOP_CTRL_SET(vop, mipi_pin_pol, pin_pol); > VOP_CTRL_SET(vop, mipi_en, 1); > break; > + case DRM_MODE_CONNECTOR_DisplayPort: > + pin_pol &= ~BIT(DCLK_INVERT); > + VOP_CTRL_SET(vop, dp_pin_pol, pin_pol); > + VOP_CTRL_SET(vop, dp_en, 1); > + break; > default: > DRM_ERROR("unsupport connector_type[%d]\n", s->output_type); > } > diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_vop.h b/drivers/gpu/drm/rockchip/rockchip_drm_vop.h > index ff4f52e..4820a8b 100644 > --- a/drivers/gpu/drm/rockchip/rockchip_drm_vop.h > +++ b/drivers/gpu/drm/rockchip/rockchip_drm_vop.h > @@ -45,6 +45,7 @@ struct vop_ctrl { > struct vop_reg edp_en; > struct vop_reg hdmi_en; > struct vop_reg mipi_en; > + struct vop_reg dp_en; > struct vop_reg out_mode; > struct vop_reg dither_down; > struct vop_reg dither_up; > @@ -53,6 +54,7 @@ struct vop_ctrl { > struct vop_reg hdmi_pin_pol; > struct vop_reg edp_pin_pol; > struct vop_reg mipi_pin_pol; > + struct vop_reg dp_pin_pol; > > struct vop_reg htotal_pw; > struct vop_reg hact_st_end; > @@ -242,6 +244,13 @@ enum scale_down_mode { > SCALE_DOWN_AVG = 0x1 > }; > > +enum vop_pol { > + HSYNC_POSITIVE = 0, > + VSYNC_POSITIVE = 1, > + DEN_NEGATIVE = 2, > + DCLK_INVERT = 3 > +}; > + > #define FRAC_16_16(mult, div) (((mult) << 16) / (div)) > #define SCL_FT_DEFAULT_FIXPOINT_SHIFT 12 > #define SCL_MAX_VSKIPLINES 4 > diff --git a/drivers/gpu/drm/rockchip/rockchip_vop_reg.c b/drivers/gpu/drm/rockchip/rockchip_vop_reg.c > index 5b1ae1f..dcf172e 100644 > --- a/drivers/gpu/drm/rockchip/rockchip_vop_reg.c > +++ b/drivers/gpu/drm/rockchip/rockchip_vop_reg.c > @@ -281,6 +281,7 @@ static const struct vop_data rk3288_vop = { > static const struct vop_ctrl rk3399_ctrl_data = { > .standby = VOP_REG(RK3399_SYS_CTRL, 0x1, 22), > .gate_en = VOP_REG(RK3399_SYS_CTRL, 0x1, 23), > + .dp_en = VOP_REG(RK3399_SYS_CTRL, 0x1, 11), > .rgb_en = VOP_REG(RK3399_SYS_CTRL, 0x1, 12), > .hdmi_en = VOP_REG(RK3399_SYS_CTRL, 0x1, 13), > .edp_en = VOP_REG(RK3399_SYS_CTRL, 0x1, 14), > @@ -290,6 +291,7 @@ static const struct vop_ctrl rk3399_ctrl_data = { > .data_blank = VOP_REG(RK3399_DSP_CTRL0, 0x1, 19), > .out_mode = VOP_REG(RK3399_DSP_CTRL0, 0xf, 0), > .rgb_pin_pol = VOP_REG(RK3399_DSP_CTRL1, 0xf, 16), > + .dp_pin_pol = VOP_REG(RK3399_DSP_CTRL1, 0xf, 16), > .hdmi_pin_pol = VOP_REG(RK3399_DSP_CTRL1, 0xf, 20), > .edp_pin_pol = VOP_REG(RK3399_DSP_CTRL1, 0xf, 24), > .mipi_pin_pol = VOP_REG(RK3399_DSP_CTRL1, 0xf, 28), -- ?ark Yao ??? Rockchip ??????????? Fuzhou Headquarters Addr:No.21 Building, A District, Fuzhou Software Park, 89 Soft Avenue, Tongpan Road, Gulou District, Fuzhou (350003) ??:?????????????89????A?21?? (350003) Tel:?86-0591?83991906 - 8296 E-mail:mark.yao at rock-chips.com