From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from oproxy7-pub.bluehost.com ([67.222.55.9]:45267 "HELO oproxy7-pub.bluehost.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with SMTP id S1750789Ab1FTU0G (ORCPT ); Mon, 20 Jun 2011 16:26:06 -0400 Received: from c-67-161-37-189.hsd1.ca.comcast.net ([67.161.37.189] helo=jbarnes-desktop) by box514.bluehost.com with esmtpsa (TLSv1:AES128-SHA:128) (Exim 4.69) (envelope-from ) id 1QYl2r-000497-9Y for linux-media@vger.kernel.org; Mon, 20 Jun 2011 14:26:05 -0600 From: Jesse Barnes (by way of Jesse Barnes ) To: dri-devel@lists.freedesktop.org Cc: intel-gfx@lists.freedesktop.org, Marcus Lorentzon , Alan Cox , Jesse Barnes Date: Mon, 20 Jun 2011 13:11:41 -0700 Message-Id: <1308600701-7442-5-git-send-email-jbarnes@virtuousgeek.org> In-Reply-To: <1308600701-7442-1-git-send-email-jbarnes@virtuousgeek.org> References: <1308600701-7442-1-git-send-email-jbarnes@virtuousgeek.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Subject: [PATCH 4/4] drm/i915: add SNB video sprite support List-ID: Sender: The video sprites support video surface formats natively and can handle scaling well. So add support for them using the new DRM core overlay support functions. Signed-off-by: Jesse Barnes --- drivers/gpu/drm/i915/Makefile | 1 + drivers/gpu/drm/i915/i915_reg.h | 52 +++++++++ drivers/gpu/drm/i915/intel_display.c | 19 +++- drivers/gpu/drm/i915/intel_drv.h | 14 +++ drivers/gpu/drm/i915/intel_fb.c | 6 + drivers/gpu/drm/i915/intel_overlay2.c | 188 +++++++++++++++++++++++++++++++++ 6 files changed, 274 insertions(+), 6 deletions(-) create mode 100644 drivers/gpu/drm/i915/intel_overlay2.c diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile index 0ae6a7c..6193471 100644 --- a/drivers/gpu/drm/i915/Makefile +++ b/drivers/gpu/drm/i915/Makefile @@ -28,6 +28,7 @@ i915-y := i915_drv.o i915_dma.o i915_irq.o i915_mem.o \ intel_dvo.o \ intel_ringbuffer.o \ intel_overlay.o \ + intel_overlay2.o \ intel_opregion.o \ dvo_ch7xxx.o \ dvo_ch7017.o \ diff --git a/drivers/gpu/drm/i915/i915_reg.h b/drivers/gpu/drm/i915/i915_reg.h index 2f967af..c81c4e7 100644 --- a/drivers/gpu/drm/i915/i915_reg.h +++ b/drivers/gpu/drm/i915/i915_reg.h @@ -2627,6 +2627,58 @@ #define _DSPBSURF 0x7119C #define _DSPBTILEOFF 0x711A4 +/* Sprite A control */ +#define _DVSACNTR 0x72180 +#define DVS_ENABLE (1<<31) +#define DVS_GAMMA_ENABLE (1<<30) +#define DVS_PIXFORMAT_MASK (3<<25) +#define DVS_FORMAT_YUV422 (0<<25) +#define DVS_FORMAT_RGBX101010 (1<<25) +#define DVS_FORMAT_RGBX888 (2<<25) +#define DVS_FORMAT_RGBX161616 (3<<25) +#define DVS_SOURCE_KEY (1<<22) +#define DVS_RGB_ORDER_RGBX (1<<20) +#define DVS_YUV_BYTE_ORDER_MASK (3<<16) +#define DVS_YUV_ORDER_YUYV (0<<16) +#define DVS_YUV_ORDER_UYVY (1<<16) +#define DVS_YUV_ORDER_YVYU (2<<16) +#define DVS_YUV_ORDER_VYUY (3<<16) +#define DVS_DEST_KEY (1<<2) +#define DVS_TRICKLE_FEED_DISABLE (1<<14) +#define DVS_TILED (1<<10) +#define _DVSASTRIDE 0x72188 +#define _DVSAPOS 0x7218c +#define _DVSASIZE 0x72190 +#define _DVSAKEYVAL 0x72194 +#define _DVSAKEYMSK 0x72198 +#define _DVSASURF 0x7219c +#define _DVSAKEYMAXVAL 0x721a0 +#define _DVSATILEOFF 0x721a4 +#define _DVSASURFLIVE 0x721ac +#define _DVSASCALE 0x72204 +#define _DVSAGAMC 0x72300 + +#define _DVSBCNTR 0x73180 +#define _DVSBSTRIDE 0x73188 +#define _DVSBPOS 0x7318c +#define _DVSBSIZE 0x73190 +#define _DVSBKEYVAL 0x73194 +#define _DVSBKEYMSK 0x73198 +#define _DVSBSURF 0x7319c +#define _DVSBKEYMAXVAL 0x731a0 +#define _DVSBTILEOFF 0x731a4 +#define _DVSBSURFLIVE 0x731ac +#define _DVSBSCALE 0x73204 +#define _DVSBGAMC 0x73300 + +#define DVSCNTR(pipe) _PIPE(pipe, _DVSACNTR, _DVSBCNTR) +#define DVSSTRIDE(pipe) _PIPE(pipe, _DVSASTRIDE, _DVSBSTRIDE) +#define DVSPOS(pipe) _PIPE(pipe, _DVSAPOS, _DVSBPOS) +#define DVSSURF(pipe) _PIPE(pipe, _DVSASURF, _DVSBSURF) +#define DVSSIZE(pipe) _PIPE(pipe, _DVSASIZE, _DVSBSIZE) +#define DVSSCALE(pipe) _PIPE(pipe, _DVSASCALE, _DVSBSCALE) +#define DVSTILEOFF(pipe) _PIPE(pipe, _DVSATILEOFF, _DVSBTILEOFF) + /* VBIOS regs */ #define VGACNTRL 0x71400 # define VGA_DISP_DISABLE (1 << 31) diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c index 7901f16..72a570a 100644 --- a/drivers/gpu/drm/i915/intel_display.c +++ b/drivers/gpu/drm/i915/intel_display.c @@ -900,8 +900,8 @@ static void assert_panel_unlocked(struct drm_i915_private *dev_priv, pipe_name(pipe)); } -static void assert_pipe(struct drm_i915_private *dev_priv, - enum pipe pipe, bool state) +void assert_pipe(struct drm_i915_private *dev_priv, + enum pipe pipe, bool state) { int reg; u32 val; @@ -914,8 +914,6 @@ static void assert_pipe(struct drm_i915_private *dev_priv, "pipe %c assertion failure (expected %s, current %s)\n", pipe_name(pipe), state_string(state), state_string(cur_state)); } -#define assert_pipe_enabled(d, p) assert_pipe(d, p, true) -#define assert_pipe_disabled(d, p) assert_pipe(d, p, false) static void assert_plane_enabled(struct drm_i915_private *dev_priv, enum plane plane) @@ -4319,7 +4317,8 @@ static void sandybridge_update_wm(struct drm_device *dev) &sandybridge_cursor_wm_info, latency, &plane_wm, &cursor_wm)) { I915_WRITE(WM0_PIPEA_ILK, - (plane_wm << WM0_PIPE_PLANE_SHIFT) | cursor_wm); + (plane_wm << WM0_PIPE_PLANE_SHIFT) | + (plane_wm << WM0_PIPE_SPRITE_SHIFT) | cursor_wm); DRM_DEBUG_KMS("FIFO watermarks For pipe A -" " plane %d, " "cursor: %d\n", plane_wm, cursor_wm); @@ -4331,7 +4330,8 @@ static void sandybridge_update_wm(struct drm_device *dev) &sandybridge_cursor_wm_info, latency, &plane_wm, &cursor_wm)) { I915_WRITE(WM0_PIPEB_ILK, - (plane_wm << WM0_PIPE_PLANE_SHIFT) | cursor_wm); + (plane_wm << WM0_PIPE_PLANE_SHIFT) | + (plane_wm << WM0_PIPE_SPRITE_SHIFT) | cursor_wm); DRM_DEBUG_KMS("FIFO watermarks For pipe B -" " plane %d, cursor: %d\n", plane_wm, cursor_wm); @@ -4371,6 +4371,11 @@ static void sandybridge_update_wm(struct drm_device *dev) (plane_wm << WM1_LP_SR_SHIFT) | cursor_wm); +#if 0 + I915_WRITE(WM1S_LP_ILK, + WM1S_LP_EN | +#endif + /* WM2 */ if (!ironlake_compute_srwm(dev, 2, enabled, SNB_READ_WM2_LATENCY() * 500, @@ -8013,6 +8018,8 @@ void intel_modeset_init(struct drm_device *dev) for (i = 0; i < dev_priv->num_pipe; i++) { intel_crtc_init(dev, i); + if (HAS_PCH_SPLIT(dev)) + intel_plane_init(dev, i); } /* Just disable it once at startup */ diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h index d73e622..232d797 100644 --- a/drivers/gpu/drm/i915/intel_drv.h +++ b/drivers/gpu/drm/i915/intel_drv.h @@ -173,10 +173,18 @@ struct intel_crtc { unsigned int bpp; }; +struct intel_plane { + struct drm_plane base; + enum pipe pipe; + struct drm_i915_gem_object *obj; + u32 lut_r[1024], lut_g[1024], lut_b[1024]; +}; + #define to_intel_crtc(x) container_of(x, struct intel_crtc, base) #define to_intel_connector(x) container_of(x, struct intel_connector, base) #define to_intel_encoder(x) container_of(x, struct intel_encoder, base) #define to_intel_framebuffer(x) container_of(x, struct intel_framebuffer, base) +#define to_intel_plane(x) container_of(x, struct intel_plane, base) #define DIP_TYPE_AVI 0x82 #define DIP_VERSION_AVI 0x2 @@ -255,6 +263,7 @@ intel_dp_set_m_n(struct drm_crtc *crtc, struct drm_display_mode *mode, extern bool intel_dpd_is_edp(struct drm_device *dev); extern void intel_edp_link_config (struct intel_encoder *, int *, int *); extern bool intel_encoder_is_pch_edp(struct drm_encoder *encoder); +extern void intel_plane_init(struct drm_device *dev, enum pipe pipe); /* intel_panel.c */ extern void intel_fixed_panel_mode(struct drm_display_mode *fixed_mode, @@ -346,5 +355,10 @@ extern int intel_overlay_attrs(struct drm_device *dev, void *data, extern void intel_fb_output_poll_changed(struct drm_device *dev); extern void intel_fb_restore_mode(struct drm_device *dev); +extern void assert_pipe(struct drm_i915_private *dev_priv, enum pipe pipe, + bool state); +#define assert_pipe_enabled(d, p) assert_pipe(d, p, true) +#define assert_pipe_disabled(d, p) assert_pipe(d, p, false) + extern void intel_init_clock_gating(struct drm_device *dev); #endif /* __INTEL_DRV_H__ */ diff --git a/drivers/gpu/drm/i915/intel_fb.c b/drivers/gpu/drm/i915/intel_fb.c index 11baa99..513a40c 100644 --- a/drivers/gpu/drm/i915/intel_fb.c +++ b/drivers/gpu/drm/i915/intel_fb.c @@ -270,8 +270,14 @@ void intel_fb_restore_mode(struct drm_device *dev) { int ret; drm_i915_private_t *dev_priv = dev->dev_private; + struct drm_mode_config *config = &dev->mode_config; + struct drm_plane *plane; ret = drm_fb_helper_restore_fbdev_mode(&dev_priv->fbdev->helper); if (ret) DRM_DEBUG("failed to restore crtc mode\n"); + + /* Be sure to shut off any planes that may be active */ + list_for_each_entry(plane, &config->plane_list, head) + plane->funcs->disable_plane(plane); } diff --git a/drivers/gpu/drm/i915/intel_overlay2.c b/drivers/gpu/drm/i915/intel_overlay2.c new file mode 100644 index 0000000..19fd76f --- /dev/null +++ b/drivers/gpu/drm/i915/intel_overlay2.c @@ -0,0 +1,188 @@ +/* + * Copyright © 2011 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + * Authors: + * Jesse Barnes + * + * New plane/sprite handling. + * + * The older chips had a separate interface for programming plane related + * registers; newer ones are much simpler and we can use the new DRM plane + * support. + */ +#include "drmP.h" +#include "drm_crtc.h" +#include "intel_drv.h" +#include "i915_drm.h" +#include "i915_drv.h" + +static int +intel_update_plane(struct drm_plane *plane, struct drm_crtc *crtc, + struct drm_framebuffer *fb, int crtc_x, int crtc_y, + unsigned int crtc_w, unsigned int crtc_h, + uint32_t src_x, uint32_t src_y, + uint32_t src_w, uint32_t src_h) +{ + struct drm_device *dev = plane->dev; + struct drm_i915_private *dev_priv = dev->dev_private; + struct intel_plane *intel_plane = to_intel_plane(plane); + struct intel_framebuffer *intel_fb; + struct drm_i915_gem_object *obj, *old_obj; + int pipe = intel_plane->pipe; + unsigned long start, offset; + u32 dvscntr; + u32 reg = DVSCNTR(pipe); + int ret = 0; + int x = src_x >> 16, y = src_y >> 16; + + assert_pipe_enabled(dev_priv, pipe); + + intel_fb = to_intel_framebuffer(fb); + obj = intel_fb->obj; + + old_obj = intel_plane->obj; + + mutex_lock(&dev->struct_mutex); + ret = intel_pin_and_fence_fb_obj(dev, obj, NULL); + if (ret) + goto out_unlock; + + intel_plane->obj = obj; + + dvscntr = I915_READ(reg); + + /* Mask out pixel format bits in case we change it */ + dvscntr &= ~DVS_PIXFORMAT_MASK; + dvscntr &= ~DVS_RGB_ORDER_RGBX; + dvscntr &= ~DVS_YUV_BYTE_ORDER_MASK; + + switch (fb->pixel_format) { + case V4L2_PIX_FMT_BGR32: + dvscntr |= DVS_FORMAT_RGBX888; + break; + case V4L2_PIX_FMT_RGB32: + dvscntr |= DVS_FORMAT_RGBX888 | DVS_RGB_ORDER_RGBX; + break; + case V4L2_PIX_FMT_YUYV: + dvscntr |= DVS_FORMAT_YUV422 | DVS_YUV_ORDER_YUYV; + break; + case V4L2_PIX_FMT_YVYU: + dvscntr |= DVS_FORMAT_YUV422 | DVS_YUV_ORDER_YVYU; + break; + case V4L2_PIX_FMT_UYVY: + dvscntr |= DVS_FORMAT_YUV422 | DVS_YUV_ORDER_UYVY; + break; + case V4L2_PIX_FMT_VYUY: + dvscntr |= DVS_FORMAT_YUV422 | DVS_YUV_ORDER_VYUY; + break; + default: + ret = -EINVAL; + DRM_DEBUG_KMS("bad pixel format\n"); + goto out_unlock; + } + + if (obj->tiling_mode != I915_TILING_X) { + DRM_DEBUG_KMS("plane surfaces must be X tiled\n"); + ret = -EINVAL; + goto out_unlock; + } + + dvscntr |= DVS_TILED; + + /* must disable */ + dvscntr |= DVS_TRICKLE_FEED_DISABLE; + dvscntr |= DVS_DEST_KEY; + dvscntr |= DVS_ENABLE; + + start = obj->gtt_offset; + offset = y * fb->pitch + x * (fb->bits_per_pixel / 8); + + I915_WRITE(DVSSTRIDE(pipe), fb->pitch); + I915_WRITE(DVSPOS(pipe), (crtc_y << 16) | crtc_x); + I915_WRITE(DVSTILEOFF(pipe), (y << 16) | x); + I915_WRITE(DVSSIZE(pipe), (fb->height << 16) | fb->width); + I915_WRITE(DVSSCALE(pipe), 0); + I915_WRITE(reg, dvscntr); + I915_WRITE(DVSSURF(pipe), start); + POSTING_READ(DVSSURF(pipe)); + + /* Unpin old obj after new one is active to avoid ugliness */ + if (old_obj) { + intel_wait_for_vblank(dev, to_intel_crtc(crtc)->pipe); + i915_gem_object_unpin(old_obj); + } + +out_unlock: + mutex_unlock(&dev->struct_mutex); + + return ret; +} + +static void +intel_disable_plane(struct drm_plane *plane) +{ + struct drm_device *dev = plane->dev; + struct drm_i915_private *dev_priv = dev->dev_private; + struct intel_plane *intel_plane = to_intel_plane(plane); + int pipe = intel_plane->pipe; + + I915_WRITE(DVSCNTR(pipe), I915_READ(DVSCNTR(pipe)) & ~DVS_ENABLE); + I915_WRITE(DVSSURF(pipe), 0); + POSTING_READ(DVSSURF(pipe)); +} + +static const struct drm_plane_funcs intel_plane_funcs = { + .update_plane = intel_update_plane, + .disable_plane = intel_disable_plane, +}; + +static uint32_t snb_plane_formats[] = { + V4L2_PIX_FMT_BGR32, + V4L2_PIX_FMT_RGB32, + V4L2_PIX_FMT_YUYV, + V4L2_PIX_FMT_YVYU, + V4L2_PIX_FMT_UYVY, + V4L2_PIX_FMT_VYUY, +}; + +void +intel_plane_init(struct drm_device *dev, enum pipe pipe) +{ + struct intel_plane *intel_plane; + unsigned long possible_crtcs; + + if (!IS_GEN6(dev)) { + DRM_ERROR("new plane code only for SNB\n"); + return; + } + + intel_plane = kzalloc(sizeof(struct intel_plane), GFP_KERNEL); + if (!intel_plane) + return; + + intel_plane->pipe = pipe; + possible_crtcs = (1 << pipe); + drm_plane_init(dev, &intel_plane->base, possible_crtcs, + &intel_plane_funcs, snb_plane_formats, + ARRAY_SIZE(snb_plane_formats)); +} + -- 1.7.4.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jesse Barnes Subject: =?UTF-8?q?=5BPATCH=204/4=5D=20drm/i915=3A=20add=20SNB=20video=20sprite=20support?= Date: Mon, 20 Jun 2011 13:11:41 -0700 Message-ID: <1308600701-7442-5-git-send-email-jbarnes@virtuousgeek.org> References: <1308600701-7442-1-git-send-email-jbarnes@virtuousgeek.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from oproxy4-pub.bluehost.com (oproxy4-pub.bluehost.com [69.89.21.11]) by gabe.freedesktop.org (Postfix) with SMTP id 7A9949F065 for ; Mon, 20 Jun 2011 13:12:35 -0700 (PDT) In-Reply-To: <1308600701-7442-1-git-send-email-jbarnes@virtuousgeek.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: dri-devel-bounces+sf-dri-devel=m.gmane.org@lists.freedesktop.org Errors-To: dri-devel-bounces+sf-dri-devel=m.gmane.org@lists.freedesktop.org To: dri-devel@lists.freedesktop.org Cc: intel-gfx@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org VGhlIHZpZGVvIHNwcml0ZXMgc3VwcG9ydCB2aWRlbyBzdXJmYWNlIGZvcm1hdHMgbmF0aXZlbHkg YW5kIGNhbiBoYW5kbGUKc2NhbGluZyB3ZWxsLiAgU28gYWRkIHN1cHBvcnQgZm9yIHRoZW0gdXNp bmcgdGhlIG5ldyBEUk0gY29yZSBvdmVybGF5CnN1cHBvcnQgZnVuY3Rpb25zLgoKU2lnbmVkLW9m Zi1ieTogSmVzc2UgQmFybmVzIDxqYmFybmVzQHZpcnR1b3VzZ2Vlay5vcmc+Ci0tLQogZHJpdmVy cy9ncHUvZHJtL2k5MTUvTWFrZWZpbGUgICAgICAgICB8ICAgIDEgKwogZHJpdmVycy9ncHUvZHJt L2k5MTUvaTkxNV9yZWcuaCAgICAgICB8ICAgNTIgKysrKysrKysrCiBkcml2ZXJzL2dwdS9kcm0v aTkxNS9pbnRlbF9kaXNwbGF5LmMgIHwgICAxOSArKystCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9p bnRlbF9kcnYuaCAgICAgIHwgICAxNCArKysKIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Zi LmMgICAgICAgfCAgICA2ICsKIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX292ZXJsYXkyLmMg fCAgMTg4ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwogNiBmaWxlcyBjaGFuZ2Vk LCAyNzQgaW5zZXJ0aW9ucygrKSwgNiBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBk cml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9vdmVybGF5Mi5jCgpkaWZmIC0tZ2l0IGEvZHJpdmVy cy9ncHUvZHJtL2k5MTUvTWFrZWZpbGUgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9NYWtlZmlsZQpp bmRleCAwYWU2YTdjLi42MTkzNDcxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9N YWtlZmlsZQorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9NYWtlZmlsZQpAQCAtMjgsNiArMjgs NyBAQCBpOTE1LXkgOj0gaTkxNV9kcnYubyBpOTE1X2RtYS5vIGk5MTVfaXJxLm8gaTkxNV9tZW0u byBcCiAJICBpbnRlbF9kdm8ubyBcCiAJICBpbnRlbF9yaW5nYnVmZmVyLm8gXAogCSAgaW50ZWxf b3ZlcmxheS5vIFwKKwkgIGludGVsX292ZXJsYXkyLm8gXAogCSAgaW50ZWxfb3ByZWdpb24ubyBc CiAJICBkdm9fY2g3eHh4Lm8gXAogCSAgZHZvX2NoNzAxNy5vIFwKZGlmZiAtLWdpdCBhL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2k5MTVfcmVnLmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3Jl Zy5oCmluZGV4IDJmOTY3YWYuLmM4MWM0ZTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2k5MTVfcmVnLmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9yZWcuaApAQCAt MjYyNyw2ICsyNjI3LDU4IEBACiAjZGVmaW5lIF9EU1BCU1VSRgkJMHg3MTE5QwogI2RlZmluZSBf RFNQQlRJTEVPRkYJCTB4NzExQTQKIAorLyogU3ByaXRlIEEgY29udHJvbCAqLworI2RlZmluZSBf RFZTQUNOVFIJCTB4NzIxODAKKyNkZWZpbmUgICBEVlNfRU5BQkxFCQkoMTw8MzEpCisjZGVmaW5l ICAgRFZTX0dBTU1BX0VOQUJMRQkoMTw8MzApCisjZGVmaW5lICAgRFZTX1BJWEZPUk1BVF9NQVNL CSgzPDwyNSkKKyNkZWZpbmUgICBEVlNfRk9STUFUX1lVVjQyMgkoMDw8MjUpCisjZGVmaW5lICAg RFZTX0ZPUk1BVF9SR0JYMTAxMDEwCSgxPDwyNSkKKyNkZWZpbmUgICBEVlNfRk9STUFUX1JHQlg4 ODgJKDI8PDI1KQorI2RlZmluZSAgIERWU19GT1JNQVRfUkdCWDE2MTYxNgkoMzw8MjUpCisjZGVm aW5lICAgRFZTX1NPVVJDRV9LRVkJKDE8PDIyKQorI2RlZmluZSAgIERWU19SR0JfT1JERVJfUkdC WAkoMTw8MjApCisjZGVmaW5lICAgRFZTX1lVVl9CWVRFX09SREVSX01BU0sgKDM8PDE2KQorI2Rl ZmluZSAgIERWU19ZVVZfT1JERVJfWVVZVgkoMDw8MTYpCisjZGVmaW5lICAgRFZTX1lVVl9PUkRF Ul9VWVZZCSgxPDwxNikKKyNkZWZpbmUgICBEVlNfWVVWX09SREVSX1lWWVUJKDI8PDE2KQorI2Rl ZmluZSAgIERWU19ZVVZfT1JERVJfVllVWQkoMzw8MTYpCisjZGVmaW5lICAgRFZTX0RFU1RfS0VZ CQkoMTw8MikKKyNkZWZpbmUgICBEVlNfVFJJQ0tMRV9GRUVEX0RJU0FCTEUgKDE8PDE0KQorI2Rl ZmluZSAgIERWU19USUxFRAkJKDE8PDEwKQorI2RlZmluZSBfRFZTQVNUUklERQkJMHg3MjE4OAor I2RlZmluZSBfRFZTQVBPUwkJMHg3MjE4YworI2RlZmluZSBfRFZTQVNJWkUJCTB4NzIxOTAKKyNk ZWZpbmUgX0RWU0FLRVlWQUwJCTB4NzIxOTQKKyNkZWZpbmUgX0RWU0FLRVlNU0sJCTB4NzIxOTgK KyNkZWZpbmUgX0RWU0FTVVJGCQkweDcyMTljCisjZGVmaW5lIF9EVlNBS0VZTUFYVkFMCQkweDcy MWEwCisjZGVmaW5lIF9EVlNBVElMRU9GRgkJMHg3MjFhNAorI2RlZmluZSBfRFZTQVNVUkZMSVZF CQkweDcyMWFjCisjZGVmaW5lIF9EVlNBU0NBTEUJCTB4NzIyMDQKKyNkZWZpbmUgX0RWU0FHQU1D CQkweDcyMzAwCisKKyNkZWZpbmUgX0RWU0JDTlRSCQkweDczMTgwCisjZGVmaW5lIF9EVlNCU1RS SURFCQkweDczMTg4CisjZGVmaW5lIF9EVlNCUE9TCQkweDczMThjCisjZGVmaW5lIF9EVlNCU0la RQkJMHg3MzE5MAorI2RlZmluZSBfRFZTQktFWVZBTAkJMHg3MzE5NAorI2RlZmluZSBfRFZTQktF WU1TSwkJMHg3MzE5OAorI2RlZmluZSBfRFZTQlNVUkYJCTB4NzMxOWMKKyNkZWZpbmUgX0RWU0JL RVlNQVhWQUwJCTB4NzMxYTAKKyNkZWZpbmUgX0RWU0JUSUxFT0ZGCQkweDczMWE0CisjZGVmaW5l IF9EVlNCU1VSRkxJVkUJCTB4NzMxYWMKKyNkZWZpbmUgX0RWU0JTQ0FMRQkJMHg3MzIwNAorI2Rl ZmluZSBfRFZTQkdBTUMJCTB4NzMzMDAKKworI2RlZmluZSBEVlNDTlRSKHBpcGUpIF9QSVBFKHBp cGUsIF9EVlNBQ05UUiwgX0RWU0JDTlRSKQorI2RlZmluZSBEVlNTVFJJREUocGlwZSkgX1BJUEUo cGlwZSwgX0RWU0FTVFJJREUsIF9EVlNCU1RSSURFKQorI2RlZmluZSBEVlNQT1MocGlwZSkgX1BJ UEUocGlwZSwgX0RWU0FQT1MsIF9EVlNCUE9TKQorI2RlZmluZSBEVlNTVVJGKHBpcGUpIF9QSVBF KHBpcGUsIF9EVlNBU1VSRiwgX0RWU0JTVVJGKQorI2RlZmluZSBEVlNTSVpFKHBpcGUpIF9QSVBF KHBpcGUsIF9EVlNBU0laRSwgX0RWU0JTSVpFKQorI2RlZmluZSBEVlNTQ0FMRShwaXBlKSBfUElQ RShwaXBlLCBfRFZTQVNDQUxFLCBfRFZTQlNDQUxFKQorI2RlZmluZSBEVlNUSUxFT0ZGKHBpcGUp IF9QSVBFKHBpcGUsIF9EVlNBVElMRU9GRiwgX0RWU0JUSUxFT0ZGKQorCiAvKiBWQklPUyByZWdz ICovCiAjZGVmaW5lIFZHQUNOVFJMCQkweDcxNDAwCiAjIGRlZmluZSBWR0FfRElTUF9ESVNBQkxF CQkJKDEgPDwgMzEpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNw bGF5LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMKaW5kZXggNzkwMWYx Ni4uNzJhNTcwYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxh eS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYwpAQCAtOTAwLDgg KzkwMCw4IEBAIHN0YXRpYyB2b2lkIGFzc2VydF9wYW5lbF91bmxvY2tlZChzdHJ1Y3QgZHJtX2k5 MTVfcHJpdmF0ZSAqZGV2X3ByaXYsCiAJICAgICBwaXBlX25hbWUocGlwZSkpOwogfQogCi1zdGF0 aWMgdm9pZCBhc3NlcnRfcGlwZShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYsCi0J CQllbnVtIHBpcGUgcGlwZSwgYm9vbCBzdGF0ZSkKK3ZvaWQgYXNzZXJ0X3BpcGUoc3RydWN0IGRy bV9pOTE1X3ByaXZhdGUgKmRldl9wcml2LAorCQkgZW51bSBwaXBlIHBpcGUsIGJvb2wgc3RhdGUp CiB7CiAJaW50IHJlZzsKIAl1MzIgdmFsOwpAQCAtOTE0LDggKzkxNCw2IEBAIHN0YXRpYyB2b2lk IGFzc2VydF9waXBlKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiwKIAkgICAgICJw aXBlICVjIGFzc2VydGlvbiBmYWlsdXJlIChleHBlY3RlZCAlcywgY3VycmVudCAlcylcbiIsCiAJ ICAgICBwaXBlX25hbWUocGlwZSksIHN0YXRlX3N0cmluZyhzdGF0ZSksIHN0YXRlX3N0cmluZyhj dXJfc3RhdGUpKTsKIH0KLSNkZWZpbmUgYXNzZXJ0X3BpcGVfZW5hYmxlZChkLCBwKSBhc3NlcnRf cGlwZShkLCBwLCB0cnVlKQotI2RlZmluZSBhc3NlcnRfcGlwZV9kaXNhYmxlZChkLCBwKSBhc3Nl cnRfcGlwZShkLCBwLCBmYWxzZSkKIAogc3RhdGljIHZvaWQgYXNzZXJ0X3BsYW5lX2VuYWJsZWQo c3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2LAogCQkJCSBlbnVtIHBsYW5lIHBsYW5l KQpAQCAtNDMxOSw3ICs0MzE3LDggQEAgc3RhdGljIHZvaWQgc2FuZHlicmlkZ2VfdXBkYXRlX3dt KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCiAJCQkJICZzYW5keWJyaWRnZV9jdXJzb3Jfd21faW5m bywgbGF0ZW5jeSwKIAkJCQkgJnBsYW5lX3dtLCAmY3Vyc29yX3dtKSkgewogCQlJOTE1X1dSSVRF KFdNMF9QSVBFQV9JTEssCi0JCQkgICAocGxhbmVfd20gPDwgV00wX1BJUEVfUExBTkVfU0hJRlQp IHwgY3Vyc29yX3dtKTsKKwkJCSAgIChwbGFuZV93bSA8PCBXTTBfUElQRV9QTEFORV9TSElGVCkg fAorCQkJICAgKHBsYW5lX3dtIDw8IFdNMF9QSVBFX1NQUklURV9TSElGVCkgfCBjdXJzb3Jfd20p OwogCQlEUk1fREVCVUdfS01TKCJGSUZPIHdhdGVybWFya3MgRm9yIHBpcGUgQSAtIgogCQkJICAg ICAgIiBwbGFuZSAlZCwgIiAiY3Vyc29yOiAlZFxuIiwKIAkJCSAgICAgIHBsYW5lX3dtLCBjdXJz b3Jfd20pOwpAQCAtNDMzMSw3ICs0MzMwLDggQEAgc3RhdGljIHZvaWQgc2FuZHlicmlkZ2VfdXBk YXRlX3dtKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCiAJCQkJICZzYW5keWJyaWRnZV9jdXJzb3Jf d21faW5mbywgbGF0ZW5jeSwKIAkJCQkgJnBsYW5lX3dtLCAmY3Vyc29yX3dtKSkgewogCQlJOTE1 X1dSSVRFKFdNMF9QSVBFQl9JTEssCi0JCQkgICAocGxhbmVfd20gPDwgV00wX1BJUEVfUExBTkVf U0hJRlQpIHwgY3Vyc29yX3dtKTsKKwkJCSAgIChwbGFuZV93bSA8PCBXTTBfUElQRV9QTEFORV9T SElGVCkgfAorCQkJICAgKHBsYW5lX3dtIDw8IFdNMF9QSVBFX1NQUklURV9TSElGVCkgfCBjdXJz b3Jfd20pOwogCQlEUk1fREVCVUdfS01TKCJGSUZPIHdhdGVybWFya3MgRm9yIHBpcGUgQiAtIgog CQkJICAgICAgIiBwbGFuZSAlZCwgY3Vyc29yOiAlZFxuIiwKIAkJCSAgICAgIHBsYW5lX3dtLCBj dXJzb3Jfd20pOwpAQCAtNDM3MSw2ICs0MzcxLDExIEBAIHN0YXRpYyB2b2lkIHNhbmR5YnJpZGdl X3VwZGF0ZV93bShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQogCQkgICAocGxhbmVfd20gPDwgV00x X0xQX1NSX1NISUZUKSB8CiAJCSAgIGN1cnNvcl93bSk7CiAKKyNpZiAwCisJSTkxNV9XUklURShX TTFTX0xQX0lMSywKKwkJICAgV00xU19MUF9FTiB8CisjZW5kaWYKKwogCS8qIFdNMiAqLwogCWlm ICghaXJvbmxha2VfY29tcHV0ZV9zcndtKGRldiwgMiwgZW5hYmxlZCwKIAkJCQkgICBTTkJfUkVB RF9XTTJfTEFURU5DWSgpICogNTAwLApAQCAtODAxMyw2ICs4MDE4LDggQEAgdm9pZCBpbnRlbF9t b2Rlc2V0X2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRldikKIAogCWZvciAoaSA9IDA7IGkgPCBk ZXZfcHJpdi0+bnVtX3BpcGU7IGkrKykgewogCQlpbnRlbF9jcnRjX2luaXQoZGV2LCBpKTsKKwkJ aWYgKEhBU19QQ0hfU1BMSVQoZGV2KSkKKwkJCWludGVsX3BsYW5lX2luaXQoZGV2LCBpKTsKIAl9 CiAKIAkvKiBKdXN0IGRpc2FibGUgaXQgb25jZSBhdCBzdGFydHVwICovCmRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2lu dGVsX2Rydi5oCmluZGV4IGQ3M2U2MjIuLjIzMmQ3OTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX2Rydi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Ry di5oCkBAIC0xNzMsMTAgKzE3MywxOCBAQCBzdHJ1Y3QgaW50ZWxfY3J0YyB7CiAJdW5zaWduZWQg aW50IGJwcDsKIH07CiAKK3N0cnVjdCBpbnRlbF9wbGFuZSB7CisJc3RydWN0IGRybV9wbGFuZSBi YXNlOworCWVudW0gcGlwZSBwaXBlOworCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmo7 CisJdTMyIGx1dF9yWzEwMjRdLCBsdXRfZ1sxMDI0XSwgbHV0X2JbMTAyNF07Cit9OworCiAjZGVm aW5lIHRvX2ludGVsX2NydGMoeCkgY29udGFpbmVyX29mKHgsIHN0cnVjdCBpbnRlbF9jcnRjLCBi YXNlKQogI2RlZmluZSB0b19pbnRlbF9jb25uZWN0b3IoeCkgY29udGFpbmVyX29mKHgsIHN0cnVj dCBpbnRlbF9jb25uZWN0b3IsIGJhc2UpCiAjZGVmaW5lIHRvX2ludGVsX2VuY29kZXIoeCkgY29u dGFpbmVyX29mKHgsIHN0cnVjdCBpbnRlbF9lbmNvZGVyLCBiYXNlKQogI2RlZmluZSB0b19pbnRl bF9mcmFtZWJ1ZmZlcih4KSBjb250YWluZXJfb2YoeCwgc3RydWN0IGludGVsX2ZyYW1lYnVmZmVy LCBiYXNlKQorI2RlZmluZSB0b19pbnRlbF9wbGFuZSh4KSBjb250YWluZXJfb2YoeCwgc3RydWN0 IGludGVsX3BsYW5lLCBiYXNlKQogCiAjZGVmaW5lIERJUF9UWVBFX0FWSSAgICAweDgyCiAjZGVm aW5lIERJUF9WRVJTSU9OX0FWSSAweDIKQEAgLTI1NSw2ICsyNjMsNyBAQCBpbnRlbF9kcF9zZXRf bV9uKHN0cnVjdCBkcm1fY3J0YyAqY3J0Yywgc3RydWN0IGRybV9kaXNwbGF5X21vZGUgKm1vZGUs CiBleHRlcm4gYm9vbCBpbnRlbF9kcGRfaXNfZWRwKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpOwog ZXh0ZXJuIHZvaWQgaW50ZWxfZWRwX2xpbmtfY29uZmlnIChzdHJ1Y3QgaW50ZWxfZW5jb2RlciAq LCBpbnQgKiwgaW50ICopOwogZXh0ZXJuIGJvb2wgaW50ZWxfZW5jb2Rlcl9pc19wY2hfZWRwKHN0 cnVjdCBkcm1fZW5jb2RlciAqZW5jb2Rlcik7CitleHRlcm4gdm9pZCBpbnRlbF9wbGFuZV9pbml0 KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIGVudW0gcGlwZSBwaXBlKTsKIAogLyogaW50ZWxfcGFu ZWwuYyAqLwogZXh0ZXJuIHZvaWQgaW50ZWxfZml4ZWRfcGFuZWxfbW9kZShzdHJ1Y3QgZHJtX2Rp c3BsYXlfbW9kZSAqZml4ZWRfbW9kZSwKQEAgLTM0Niw1ICszNTUsMTAgQEAgZXh0ZXJuIGludCBp bnRlbF9vdmVybGF5X2F0dHJzKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHZvaWQgKmRhdGEsCiBl eHRlcm4gdm9pZCBpbnRlbF9mYl9vdXRwdXRfcG9sbF9jaGFuZ2VkKHN0cnVjdCBkcm1fZGV2aWNl ICpkZXYpOwogZXh0ZXJuIHZvaWQgaW50ZWxfZmJfcmVzdG9yZV9tb2RlKHN0cnVjdCBkcm1fZGV2 aWNlICpkZXYpOwogCitleHRlcm4gdm9pZCBhc3NlcnRfcGlwZShzdHJ1Y3QgZHJtX2k5MTVfcHJp dmF0ZSAqZGV2X3ByaXYsIGVudW0gcGlwZSBwaXBlLAorCQkJYm9vbCBzdGF0ZSk7CisjZGVmaW5l IGFzc2VydF9waXBlX2VuYWJsZWQoZCwgcCkgYXNzZXJ0X3BpcGUoZCwgcCwgdHJ1ZSkKKyNkZWZp bmUgYXNzZXJ0X3BpcGVfZGlzYWJsZWQoZCwgcCkgYXNzZXJ0X3BpcGUoZCwgcCwgZmFsc2UpCisK IGV4dGVybiB2b2lkIGludGVsX2luaXRfY2xvY2tfZ2F0aW5nKHN0cnVjdCBkcm1fZGV2aWNlICpk ZXYpOwogI2VuZGlmIC8qIF9fSU5URUxfRFJWX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9n cHUvZHJtL2k5MTUvaW50ZWxfZmIuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2ZiLmMK aW5kZXggMTFiYWE5OS4uNTEzYTQwYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUv aW50ZWxfZmIuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9mYi5jCkBAIC0yNzAs OCArMjcwLDE0IEBAIHZvaWQgaW50ZWxfZmJfcmVzdG9yZV9tb2RlKHN0cnVjdCBkcm1fZGV2aWNl ICpkZXYpCiB7CiAJaW50IHJldDsKIAlkcm1faTkxNV9wcml2YXRlX3QgKmRldl9wcml2ID0gZGV2 LT5kZXZfcHJpdmF0ZTsKKwlzdHJ1Y3QgZHJtX21vZGVfY29uZmlnICpjb25maWcgPSAmZGV2LT5t b2RlX2NvbmZpZzsKKwlzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZTsKIAogCXJldCA9IGRybV9mYl9o ZWxwZXJfcmVzdG9yZV9mYmRldl9tb2RlKCZkZXZfcHJpdi0+ZmJkZXYtPmhlbHBlcik7CiAJaWYg KHJldCkKIAkJRFJNX0RFQlVHKCJmYWlsZWQgdG8gcmVzdG9yZSBjcnRjIG1vZGVcbiIpOworCisJ LyogQmUgc3VyZSB0byBzaHV0IG9mZiBhbnkgcGxhbmVzIHRoYXQgbWF5IGJlIGFjdGl2ZSAqLwor CWxpc3RfZm9yX2VhY2hfZW50cnkocGxhbmUsICZjb25maWctPnBsYW5lX2xpc3QsIGhlYWQpCisJ CXBsYW5lLT5mdW5jcy0+ZGlzYWJsZV9wbGFuZShwbGFuZSk7CiB9CmRpZmYgLS1naXQgYS9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9vdmVybGF5Mi5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUv aW50ZWxfb3ZlcmxheTIuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xOWZk NzZmCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfb3Zlcmxh eTIuYwpAQCAtMCwwICsxLDE4OCBAQAorLyoKKyAqIENvcHlyaWdodCDCqSAyMDExIEludGVsIENv cnBvcmF0aW9uCisgKgorICogUGVybWlzc2lvbiBpcyBoZXJlYnkgZ3JhbnRlZCwgZnJlZSBvZiBj aGFyZ2UsIHRvIGFueSBwZXJzb24gb2J0YWluaW5nIGEKKyAqIGNvcHkgb2YgdGhpcyBzb2Z0d2Fy ZSBhbmQgYXNzb2NpYXRlZCBkb2N1bWVudGF0aW9uIGZpbGVzICh0aGUgIlNvZnR3YXJlIiksCisg KiB0byBkZWFsIGluIHRoZSBTb2Z0d2FyZSB3aXRob3V0IHJlc3RyaWN0aW9uLCBpbmNsdWRpbmcg d2l0aG91dCBsaW1pdGF0aW9uCisgKiB0aGUgcmlnaHRzIHRvIHVzZSwgY29weSwgbW9kaWZ5LCBt ZXJnZSwgcHVibGlzaCwgZGlzdHJpYnV0ZSwgc3VibGljZW5zZSwKKyAqIGFuZC9vciBzZWxsIGNv cGllcyBvZiB0aGUgU29mdHdhcmUsIGFuZCB0byBwZXJtaXQgcGVyc29ucyB0byB3aG9tIHRoZQor ICogU29mdHdhcmUgaXMgZnVybmlzaGVkIHRvIGRvIHNvLCBzdWJqZWN0IHRvIHRoZSBmb2xsb3dp bmcgY29uZGl0aW9uczoKKyAqCisgKiBUaGUgYWJvdmUgY29weXJpZ2h0IG5vdGljZSBhbmQgdGhp cyBwZXJtaXNzaW9uIG5vdGljZSAoaW5jbHVkaW5nIHRoZSBuZXh0CisgKiBwYXJhZ3JhcGgpIHNo YWxsIGJlIGluY2x1ZGVkIGluIGFsbCBjb3BpZXMgb3Igc3Vic3RhbnRpYWwgcG9ydGlvbnMgb2Yg dGhlCisgKiBTb2Z0d2FyZS4KKyAqCisgKiBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgIkFTIElT IiwgV0lUSE9VVCBXQVJSQU5UWSBPRiBBTlkgS0lORCwgRVhQUkVTUyBPUgorICogSU1QTElFRCwg SU5DTFVESU5HIEJVVCBOT1QgTElNSVRFRCBUTyBUSEUgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFC SUxJVFksCisgKiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBTkQgTk9OSU5GUklO R0VNRU5ULiAgSU4gTk8gRVZFTlQgU0hBTEwKKyAqIFRIRSBBVVRIT1JTIE9SIENPUFlSSUdIVCBI T0xERVJTIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SIE9USEVSCisgKiBMSUFC SUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lT RSwgQVJJU0lORyBGUk9NLAorICogT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09G VFdBUkUgT1IgVEhFIFVTRSBPUiBPVEhFUiBERUFMSU5HUyBJTiBUSEUKKyAqIFNPRlRXQVJFLgor ICoKKyAqIEF1dGhvcnM6CisgKiAgIEplc3NlIEJhcm5lcyA8amJhcm5lc0B2aXJ0dW91c2dlZWsu b3JnPgorICoKKyAqIE5ldyBwbGFuZS9zcHJpdGUgaGFuZGxpbmcuCisgKgorICogVGhlIG9sZGVy IGNoaXBzIGhhZCBhIHNlcGFyYXRlIGludGVyZmFjZSBmb3IgcHJvZ3JhbW1pbmcgcGxhbmUgcmVs YXRlZAorICogcmVnaXN0ZXJzOyBuZXdlciBvbmVzIGFyZSBtdWNoIHNpbXBsZXIgYW5kIHdlIGNh biB1c2UgdGhlIG5ldyBEUk0gcGxhbmUKKyAqIHN1cHBvcnQuCisgKi8KKyNpbmNsdWRlICJkcm1Q LmgiCisjaW5jbHVkZSAiZHJtX2NydGMuaCIKKyNpbmNsdWRlICJpbnRlbF9kcnYuaCIKKyNpbmNs dWRlICJpOTE1X2RybS5oIgorI2luY2x1ZGUgImk5MTVfZHJ2LmgiCisKK3N0YXRpYyBpbnQKK2lu dGVsX3VwZGF0ZV9wbGFuZShzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSwgc3RydWN0IGRybV9jcnRj ICpjcnRjLAorCQkgICBzdHJ1Y3QgZHJtX2ZyYW1lYnVmZmVyICpmYiwgaW50IGNydGNfeCwgaW50 IGNydGNfeSwKKwkJICAgdW5zaWduZWQgaW50IGNydGNfdywgdW5zaWduZWQgaW50IGNydGNfaCwK KwkJICAgdWludDMyX3Qgc3JjX3gsIHVpbnQzMl90IHNyY195LAorCQkgICB1aW50MzJfdCBzcmNf dywgdWludDMyX3Qgc3JjX2gpCit7CisJc3RydWN0IGRybV9kZXZpY2UgKmRldiA9IHBsYW5lLT5k ZXY7CisJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0 ZTsKKwlzdHJ1Y3QgaW50ZWxfcGxhbmUgKmludGVsX3BsYW5lID0gdG9faW50ZWxfcGxhbmUocGxh bmUpOworCXN0cnVjdCBpbnRlbF9mcmFtZWJ1ZmZlciAqaW50ZWxfZmI7CisJc3RydWN0IGRybV9p OTE1X2dlbV9vYmplY3QgKm9iaiwgKm9sZF9vYmo7CisJaW50IHBpcGUgPSBpbnRlbF9wbGFuZS0+ cGlwZTsKKwl1bnNpZ25lZCBsb25nIHN0YXJ0LCBvZmZzZXQ7CisJdTMyIGR2c2NudHI7CisJdTMy IHJlZyA9IERWU0NOVFIocGlwZSk7CisJaW50IHJldCA9IDA7CisJaW50IHggPSBzcmNfeCA+PiAx NiwgeSA9IHNyY195ID4+IDE2OworCisJYXNzZXJ0X3BpcGVfZW5hYmxlZChkZXZfcHJpdiwgcGlw ZSk7CisKKwlpbnRlbF9mYiA9IHRvX2ludGVsX2ZyYW1lYnVmZmVyKGZiKTsKKwlvYmogPSBpbnRl bF9mYi0+b2JqOworCisJb2xkX29iaiA9IGludGVsX3BsYW5lLT5vYmo7CisKKwltdXRleF9sb2Nr KCZkZXYtPnN0cnVjdF9tdXRleCk7CisJcmV0ID0gaW50ZWxfcGluX2FuZF9mZW5jZV9mYl9vYmoo ZGV2LCBvYmosIE5VTEwpOworCWlmIChyZXQpCisJCWdvdG8gb3V0X3VubG9jazsKKworCWludGVs X3BsYW5lLT5vYmogPSBvYmo7CisKKwlkdnNjbnRyID0gSTkxNV9SRUFEKHJlZyk7CisKKwkvKiBN YXNrIG91dCBwaXhlbCBmb3JtYXQgYml0cyBpbiBjYXNlIHdlIGNoYW5nZSBpdCAqLworCWR2c2Nu dHIgJj0gfkRWU19QSVhGT1JNQVRfTUFTSzsKKwlkdnNjbnRyICY9IH5EVlNfUkdCX09SREVSX1JH Qlg7CisJZHZzY250ciAmPSB+RFZTX1lVVl9CWVRFX09SREVSX01BU0s7CisKKwlzd2l0Y2ggKGZi LT5waXhlbF9mb3JtYXQpIHsKKwljYXNlIFY0TDJfUElYX0ZNVF9CR1IzMjoKKwkJZHZzY250ciB8 PSBEVlNfRk9STUFUX1JHQlg4ODg7CisJCWJyZWFrOworCWNhc2UgVjRMMl9QSVhfRk1UX1JHQjMy OgorCQlkdnNjbnRyIHw9IERWU19GT1JNQVRfUkdCWDg4OCB8IERWU19SR0JfT1JERVJfUkdCWDsK KwkJYnJlYWs7CisJY2FzZSBWNEwyX1BJWF9GTVRfWVVZVjoKKwkJZHZzY250ciB8PSBEVlNfRk9S TUFUX1lVVjQyMiB8IERWU19ZVVZfT1JERVJfWVVZVjsKKwkJYnJlYWs7CisJY2FzZSBWNEwyX1BJ WF9GTVRfWVZZVToKKwkJZHZzY250ciB8PSBEVlNfRk9STUFUX1lVVjQyMiB8IERWU19ZVVZfT1JE RVJfWVZZVTsKKwkJYnJlYWs7CisJY2FzZSBWNEwyX1BJWF9GTVRfVVlWWToKKwkJZHZzY250ciB8 PSBEVlNfRk9STUFUX1lVVjQyMiB8IERWU19ZVVZfT1JERVJfVVlWWTsKKwkJYnJlYWs7CisJY2Fz ZSBWNEwyX1BJWF9GTVRfVllVWToKKwkJZHZzY250ciB8PSBEVlNfRk9STUFUX1lVVjQyMiB8IERW U19ZVVZfT1JERVJfVllVWTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJcmV0ID0gLUVJTlZBTDsK KwkJRFJNX0RFQlVHX0tNUygiYmFkIHBpeGVsIGZvcm1hdFxuIik7CisJCWdvdG8gb3V0X3VubG9j azsKKwl9CisKKwlpZiAob2JqLT50aWxpbmdfbW9kZSAhPSBJOTE1X1RJTElOR19YKSB7CisJCURS TV9ERUJVR19LTVMoInBsYW5lIHN1cmZhY2VzIG11c3QgYmUgWCB0aWxlZFxuIik7CisJCXJldCA9 IC1FSU5WQUw7CisJCWdvdG8gb3V0X3VubG9jazsKKwl9CisKKwlkdnNjbnRyIHw9IERWU19USUxF RDsKKworCS8qIG11c3QgZGlzYWJsZSAqLworCWR2c2NudHIgfD0gRFZTX1RSSUNLTEVfRkVFRF9E SVNBQkxFOworCWR2c2NudHIgfD0gRFZTX0RFU1RfS0VZOworCWR2c2NudHIgfD0gRFZTX0VOQUJM RTsKKworCXN0YXJ0ID0gb2JqLT5ndHRfb2Zmc2V0OworCW9mZnNldCA9IHkgKiBmYi0+cGl0Y2gg KyB4ICogKGZiLT5iaXRzX3Blcl9waXhlbCAvIDgpOworCisJSTkxNV9XUklURShEVlNTVFJJREUo cGlwZSksIGZiLT5waXRjaCk7CisJSTkxNV9XUklURShEVlNQT1MocGlwZSksIChjcnRjX3kgPDwg MTYpIHwgY3J0Y194KTsKKwlJOTE1X1dSSVRFKERWU1RJTEVPRkYocGlwZSksICh5IDw8IDE2KSB8 IHgpOworCUk5MTVfV1JJVEUoRFZTU0laRShwaXBlKSwgKGZiLT5oZWlnaHQgPDwgMTYpIHwgZmIt PndpZHRoKTsKKwlJOTE1X1dSSVRFKERWU1NDQUxFKHBpcGUpLCAwKTsKKwlJOTE1X1dSSVRFKHJl ZywgZHZzY250cik7CisJSTkxNV9XUklURShEVlNTVVJGKHBpcGUpLCBzdGFydCk7CisJUE9TVElO R19SRUFEKERWU1NVUkYocGlwZSkpOworCisJLyogVW5waW4gb2xkIG9iaiBhZnRlciBuZXcgb25l IGlzIGFjdGl2ZSB0byBhdm9pZCB1Z2xpbmVzcyAqLworCWlmIChvbGRfb2JqKSB7CisJCWludGVs X3dhaXRfZm9yX3ZibGFuayhkZXYsIHRvX2ludGVsX2NydGMoY3J0YyktPnBpcGUpOworCQlpOTE1 X2dlbV9vYmplY3RfdW5waW4ob2xkX29iaik7CisJfQorCitvdXRfdW5sb2NrOgorCW11dGV4X3Vu bG9jaygmZGV2LT5zdHJ1Y3RfbXV0ZXgpOworCisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIHZv aWQKK2ludGVsX2Rpc2FibGVfcGxhbmUoc3RydWN0IGRybV9wbGFuZSAqcGxhbmUpCit7CisJc3Ry dWN0IGRybV9kZXZpY2UgKmRldiA9IHBsYW5lLT5kZXY7CisJc3RydWN0IGRybV9pOTE1X3ByaXZh dGUgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKKwlzdHJ1Y3QgaW50ZWxfcGxhbmUgKmlu dGVsX3BsYW5lID0gdG9faW50ZWxfcGxhbmUocGxhbmUpOworCWludCBwaXBlID0gaW50ZWxfcGxh bmUtPnBpcGU7CisKKwlJOTE1X1dSSVRFKERWU0NOVFIocGlwZSksIEk5MTVfUkVBRChEVlNDTlRS KHBpcGUpKSAmIH5EVlNfRU5BQkxFKTsKKwlJOTE1X1dSSVRFKERWU1NVUkYocGlwZSksIDApOwor CVBPU1RJTkdfUkVBRChEVlNTVVJGKHBpcGUpKTsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBk cm1fcGxhbmVfZnVuY3MgaW50ZWxfcGxhbmVfZnVuY3MgPSB7CisJLnVwZGF0ZV9wbGFuZSA9IGlu dGVsX3VwZGF0ZV9wbGFuZSwKKwkuZGlzYWJsZV9wbGFuZSA9IGludGVsX2Rpc2FibGVfcGxhbmUs Cit9OworCitzdGF0aWMgdWludDMyX3Qgc25iX3BsYW5lX2Zvcm1hdHNbXSA9IHsKKwlWNEwyX1BJ WF9GTVRfQkdSMzIsCisJVjRMMl9QSVhfRk1UX1JHQjMyLAorCVY0TDJfUElYX0ZNVF9ZVVlWLAor CVY0TDJfUElYX0ZNVF9ZVllVLAorCVY0TDJfUElYX0ZNVF9VWVZZLAorCVY0TDJfUElYX0ZNVF9W WVVZLAorfTsKKwordm9pZAoraW50ZWxfcGxhbmVfaW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2 LCBlbnVtIHBpcGUgcGlwZSkKK3sKKwlzdHJ1Y3QgaW50ZWxfcGxhbmUgKmludGVsX3BsYW5lOwor CXVuc2lnbmVkIGxvbmcgcG9zc2libGVfY3J0Y3M7CisKKwlpZiAoIUlTX0dFTjYoZGV2KSkgewor CQlEUk1fRVJST1IoIm5ldyBwbGFuZSBjb2RlIG9ubHkgZm9yIFNOQlxuIik7CisJCXJldHVybjsK Kwl9CisKKwlpbnRlbF9wbGFuZSA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBpbnRlbF9wbGFuZSks IEdGUF9LRVJORUwpOworCWlmICghaW50ZWxfcGxhbmUpCisJCXJldHVybjsKKworCWludGVsX3Bs YW5lLT5waXBlID0gcGlwZTsKKwlwb3NzaWJsZV9jcnRjcyA9ICgxIDw8IHBpcGUpOworCWRybV9w bGFuZV9pbml0KGRldiwgJmludGVsX3BsYW5lLT5iYXNlLCBwb3NzaWJsZV9jcnRjcywKKwkJICAg ICAgICZpbnRlbF9wbGFuZV9mdW5jcywgc25iX3BsYW5lX2Zvcm1hdHMsCisJCSAgICAgICBBUlJB WV9TSVpFKHNuYl9wbGFuZV9mb3JtYXRzKSk7Cit9CisKLS0gCjEuNy40LjEKCl9fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxp c3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwOi8vbGlzdHMuZnJlZWRlc2t0 b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg==