From mboxrd@z Thu Jan 1 00:00:00 1970 From: shawnguo@kernel.org (Shawn Guo) Date: Tue, 20 Dec 2016 20:09:55 +0800 Subject: [PATCH v2] drm: zte: add overlay plane support Message-ID: <1482235795-6223-1-git-send-email-shawnguo@kernel.org> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org From: Shawn Guo It enables VOU VL (Video Layer) to support overlay plane with scaling function. VL0 has some quirks on scaling support. We chose to skip it and only adds VL1 and VL2 into DRM core for now. Signed-off-by: Shawn Guo --- Changes for v2: - Use clipped coordinates for overlay position calculation drivers/gpu/drm/zte/zx_plane.c | 293 ++++++++++++++++++++++++++++++++++-- drivers/gpu/drm/zte/zx_plane_regs.h | 51 +++++++ drivers/gpu/drm/zte/zx_vou.c | 149 +++++++++++++++++- drivers/gpu/drm/zte/zx_vou.h | 3 + drivers/gpu/drm/zte/zx_vou_regs.h | 18 +++ 5 files changed, 497 insertions(+), 17 deletions(-) diff --git a/drivers/gpu/drm/zte/zx_plane.c b/drivers/gpu/drm/zte/zx_plane.c index 546eb92a94e8..8cd7cf71b2b0 100644 --- a/drivers/gpu/drm/zte/zx_plane.c +++ b/drivers/gpu/drm/zte/zx_plane.c @@ -40,6 +40,269 @@ struct zx_plane { DRM_FORMAT_ARGB4444, }; +static const uint32_t vl_formats[] = { + DRM_FORMAT_NV12, /* Semi-planar YUV420 */ + DRM_FORMAT_YUV420, /* Planar YUV420 */ + DRM_FORMAT_YUYV, /* Packed YUV422 */ + DRM_FORMAT_YVYU, + DRM_FORMAT_UYVY, + DRM_FORMAT_VYUY, + DRM_FORMAT_YUV444, /* YUV444 8bit */ + /* + * TODO: add formats below that HW supports: + * - YUV420 P010 + * - YUV420 Hantro + * - YUV444 10bit + */ +}; + +#define FRAC_16_16(mult, div) (((mult) << 16) / (div)) + +static int zx_vl_plane_atomic_check(struct drm_plane *plane, + struct drm_plane_state *plane_state) +{ + struct drm_framebuffer *fb = plane_state->fb; + struct drm_crtc *crtc = plane_state->crtc; + struct drm_crtc_state *crtc_state; + struct drm_rect clip; + int min_scale = FRAC_16_16(1, 8); + int max_scale = FRAC_16_16(8, 1); + + if (!crtc || !fb) + return 0; + + crtc_state = drm_atomic_get_existing_crtc_state(plane_state->state, + crtc); + if (WARN_ON(!crtc_state)) + return -EINVAL; + + /* nothing to check when disabling or disabled */ + if (!crtc_state->enable) + return 0; + + /* plane must be enabled */ + if (!plane_state->crtc) + return -EINVAL; + + clip.x1 = 0; + clip.y1 = 0; + clip.x2 = crtc_state->adjusted_mode.hdisplay; + clip.y2 = crtc_state->adjusted_mode.vdisplay; + + return drm_plane_helper_check_state(plane_state, &clip, + min_scale, max_scale, + true, true); +} + +static u32 zx_vl_get_fmt(uint32_t format) +{ + u32 val = 0; + + switch (format) { + case DRM_FORMAT_NV12: + val = VL_FMT_YUV420; + break; + case DRM_FORMAT_YUV420: + val = VL_YUV420_PLANAR | VL_FMT_YUV420; + break; + case DRM_FORMAT_YUYV: + val = VL_YUV422_YUYV | VL_FMT_YUV422; + break; + case DRM_FORMAT_YVYU: + val = VL_YUV422_YVYU | VL_FMT_YUV422; + break; + case DRM_FORMAT_UYVY: + val = VL_YUV422_UYVY | VL_FMT_YUV422; + break; + case DRM_FORMAT_VYUY: + val = VL_YUV422_VYUY | VL_FMT_YUV422; + break; + case DRM_FORMAT_YUV444: + val = VL_FMT_YUV444_8BIT; + break; + default: + WARN_ONCE(1, "invalid pixel format %d\n", format); + } + + return val; +} + +static inline void zx_vl_set_update(struct zx_plane *zplane) +{ + void __iomem *layer = zplane->layer; + + zx_writel_mask(layer + VL_CTRL0, VL_UPDATE, VL_UPDATE); +} + +static inline void zx_vl_rsz_set_update(struct zx_plane *zplane) +{ + zx_writel(zplane->rsz + RSZ_VL_ENABLE_CFG, 1); +} + +static u32 zx_vl_rsz_get_fmt(uint32_t format) +{ + u32 val = 0; + + switch (format) { + case DRM_FORMAT_NV12: + case DRM_FORMAT_YUV420: + val = RSZ_VL_FMT_YCBCR420; + break; + case DRM_FORMAT_YUYV: + case DRM_FORMAT_YVYU: + case DRM_FORMAT_UYVY: + case DRM_FORMAT_VYUY: + val = RSZ_VL_FMT_YCBCR422; + break; + case DRM_FORMAT_YUV444: + val = RSZ_VL_FMT_YCBCR444; + break; + default: + WARN_ONCE(1, "invalid pixel format %d\n", format); + } + + return val; +} + +static inline u32 rsz_step_value(u32 src, u32 dst) +{ + u32 val = 0; + + if (src == dst) + val = 0; + else if (src < dst) + val = RSZ_PARA_STEP((src << 16) / dst); + else if (src > dst) + val = RSZ_DATA_STEP(src / dst) | + RSZ_PARA_STEP(((src << 16) / dst) & 0xffff); + + return val; +} + +static void zx_vl_rsz_setup(struct zx_plane *zplane, uint32_t format, + u32 src_w, u32 src_h, u32 dst_w, u32 dst_h) +{ + void __iomem *rsz = zplane->rsz; + u32 src_chroma_w = src_w; + u32 src_chroma_h = src_h; + u32 fmt; + + /* Set up source and destination resolution */ + zx_writel(rsz + RSZ_SRC_CFG, RSZ_VER(src_h - 1) | RSZ_HOR(src_w - 1)); + zx_writel(rsz + RSZ_DEST_CFG, RSZ_VER(dst_h - 1) | RSZ_HOR(dst_w - 1)); + + /* Configure data format for VL RSZ */ + fmt = zx_vl_rsz_get_fmt(format); + zx_writel_mask(rsz + RSZ_VL_CTRL_CFG, RSZ_VL_FMT_MASK, fmt); + + /* Calculate Chroma heigth and width */ + if (fmt == RSZ_VL_FMT_YCBCR420) { + src_chroma_w = src_w >> 1; + src_chroma_h = src_h >> 1; + } else if (fmt == RSZ_VL_FMT_YCBCR422) { + src_chroma_w = src_w >> 1; + } + + /* Set up Luma and Chroma step registers */ + zx_writel(rsz + RSZ_VL_LUMA_HOR, rsz_step_value(src_w, dst_w)); + zx_writel(rsz + RSZ_VL_LUMA_VER, rsz_step_value(src_h, dst_h)); + zx_writel(rsz + RSZ_VL_CHROMA_HOR, rsz_step_value(src_chroma_w, dst_w)); + zx_writel(rsz + RSZ_VL_CHROMA_VER, rsz_step_value(src_chroma_h, dst_h)); + + zx_vl_rsz_set_update(zplane); +} + +static void zx_vl_plane_atomic_update(struct drm_plane *plane, + struct drm_plane_state *old_state) +{ + struct zx_plane *zplane = to_zx_plane(plane); + struct drm_plane_state *state = plane->state; + struct drm_framebuffer *fb = state->fb; + struct drm_rect *src = &state->src; + struct drm_rect *dst = &state->dst; + struct drm_gem_cma_object *cma_obj; + void __iomem *layer = zplane->layer; + void __iomem *hbsc = zplane->hbsc; + void __iomem *paddr_reg; + dma_addr_t paddr; + u32 src_x, src_y, src_w, src_h; + u32 dst_x, dst_y, dst_w, dst_h; + uint32_t format; + u32 fmt; + int num_planes; + int i; + + if (!fb) + return; + + format = fb->pixel_format; + + src_x = src->x1 >> 16; + src_y = src->y1 >> 16; + src_w = drm_rect_width(src) >> 16; + src_h = drm_rect_height(src) >> 16; + + dst_x = dst->x1; + dst_y = dst->y1; + dst_w = drm_rect_width(dst); + dst_h = drm_rect_height(dst); + + /* Set up data address registers for Y, Cb and Cr planes */ + num_planes = drm_format_num_planes(format); + paddr_reg = layer + VL_Y; + for (i = 0; i < num_planes; i++) { + cma_obj = drm_fb_cma_get_gem_obj(fb, i); + paddr = cma_obj->paddr + fb->offsets[i]; + paddr += src_y * fb->pitches[i]; + paddr += src_x * drm_format_plane_cpp(format, i); + zx_writel(paddr_reg, paddr); + paddr_reg += 4; + } + + /* Set up source height/width register */ + zx_writel(layer + VL_SRC_SIZE, GL_SRC_W(src_w) | GL_SRC_H(src_h)); + + /* Set up start position register */ + zx_writel(layer + VL_POS_START, GL_POS_X(dst_x) | GL_POS_Y(dst_y)); + + /* Set up end position register */ + zx_writel(layer + VL_POS_END, + GL_POS_X(dst_x + dst_w) | GL_POS_Y(dst_y + dst_h)); + + /* Strides of Cb and Cr planes should be identical */ + zx_writel(layer + VL_STRIDE, LUMA_STRIDE(fb->pitches[0]) | + CHROMA_STRIDE(fb->pitches[1])); + + /* Set up video layer data format */ + fmt = zx_vl_get_fmt(format); + zx_writel(layer + VL_CTRL1, fmt); + + /* Always use scaler since it exists (set for not bypass) */ + zx_writel_mask(layer + VL_CTRL2, VL_SCALER_BYPASS_MODE, + VL_SCALER_BYPASS_MODE); + + zx_vl_rsz_setup(zplane, format, src_w, src_h, dst_w, dst_h); + + /* Enable HBSC block */ + zx_writel_mask(hbsc + HBSC_CTRL0, HBSC_CTRL_EN, HBSC_CTRL_EN); + + zx_overlay_enable(plane); + + zx_vl_set_update(zplane); +} + +static void zx_vl_plane_atomic_disable(struct drm_plane *plane, + struct drm_plane_state *old_state) +{ + zx_overlay_disable(plane); +} + +static const struct drm_plane_helper_funcs zx_vl_plane_helper_funcs = { + .atomic_check = zx_vl_plane_atomic_check, + .atomic_update = zx_vl_plane_atomic_update, + .atomic_disable = zx_vl_plane_atomic_disable, +}; + static int zx_gl_plane_atomic_check(struct drm_plane *plane, struct drm_plane_state *plane_state) { @@ -107,14 +370,6 @@ static inline void zx_gl_rsz_set_update(struct zx_plane *zplane) zx_writel(zplane->rsz + RSZ_ENABLE_CFG, 1); } -void zx_plane_set_update(struct drm_plane *plane) -{ - struct zx_plane *zplane = to_zx_plane(plane); - - zx_gl_rsz_set_update(zplane); - zx_gl_set_update(zplane); -} - static void zx_gl_rsz_setup(struct zx_plane *zplane, u32 src_w, u32 src_h, u32 dst_w, u32 dst_h) { @@ -230,6 +485,24 @@ static void zx_plane_destroy(struct drm_plane *plane) .atomic_destroy_state = drm_atomic_helper_plane_destroy_state, }; +void zx_plane_set_update(struct drm_plane *plane) +{ + struct zx_plane *zplane = to_zx_plane(plane); + + switch (plane->type) { + case DRM_PLANE_TYPE_PRIMARY: + zx_gl_rsz_set_update(zplane); + zx_gl_set_update(zplane); + break; + case DRM_PLANE_TYPE_OVERLAY: + zx_vl_rsz_set_update(zplane); + zx_vl_set_update(zplane); + break; + default: + WARN_ONCE(1, "unsupported plane type %d\n", plane->type); + } +} + static void zx_plane_hbsc_init(struct zx_plane *zplane) { void __iomem *hbsc = zplane->hbsc; @@ -279,7 +552,9 @@ struct drm_plane *zx_plane_init(struct drm_device *drm, struct device *dev, format_count = ARRAY_SIZE(gl_formats); break; case DRM_PLANE_TYPE_OVERLAY: - /* TODO: add video layer (vl) support */ + helper = &zx_vl_plane_helper_funcs; + formats = vl_formats; + format_count = ARRAY_SIZE(vl_formats); break; default: return ERR_PTR(-ENODEV); diff --git a/drivers/gpu/drm/zte/zx_plane_regs.h b/drivers/gpu/drm/zte/zx_plane_regs.h index 3dde6716a558..65f271aeabed 100644 --- a/drivers/gpu/drm/zte/zx_plane_regs.h +++ b/drivers/gpu/drm/zte/zx_plane_regs.h @@ -46,6 +46,37 @@ #define GL_POS_X(x) (((x) << GL_POS_X_SHIFT) & GL_POS_X_MASK) #define GL_POS_Y(x) (((x) << GL_POS_Y_SHIFT) & GL_POS_Y_MASK) +/* VL registers */ +#define VL_CTRL0 0x00 +#define VL_UPDATE BIT(3) +#define VL_CTRL1 0x04 +#define VL_YUV420_PLANAR BIT(5) +#define VL_YUV422_SHIFT 3 +#define VL_YUV422_YUYV (0 << VL_YUV422_SHIFT) +#define VL_YUV422_YVYU (1 << VL_YUV422_SHIFT) +#define VL_YUV422_UYVY (2 << VL_YUV422_SHIFT) +#define VL_YUV422_VYUY (3 << VL_YUV422_SHIFT) +#define VL_FMT_YUV420 0 +#define VL_FMT_YUV422 1 +#define VL_FMT_YUV420_P010 2 +#define VL_FMT_YUV420_HANTRO 3 +#define VL_FMT_YUV444_8BIT 4 +#define VL_FMT_YUV444_10BIT 5 +#define VL_CTRL2 0x08 +#define VL_SCALER_BYPASS_MODE BIT(0) +#define VL_STRIDE 0x0c +#define LUMA_STRIDE_SHIFT 16 +#define LUMA_STRIDE_MASK (0xffff << LUMA_STRIDE_SHIFT) +#define CHROMA_STRIDE_SHIFT 0 +#define CHROMA_STRIDE_MASK (0xffff << CHROMA_STRIDE_SHIFT) +#define VL_SRC_SIZE 0x10 +#define VL_Y 0x14 +#define VL_POS_START 0x30 +#define VL_POS_END 0x34 + +#define LUMA_STRIDE(x) (((x) << LUMA_STRIDE_SHIFT) & LUMA_STRIDE_MASK) +#define CHROMA_STRIDE(x) (((x) << CHROMA_STRIDE_SHIFT) & CHROMA_STRIDE_MASK) + /* CSC registers */ #define CSC_CTRL0 0x30 #define CSC_COV_MODE_SHIFT 16 @@ -69,6 +100,18 @@ #define RSZ_DEST_CFG 0x04 #define RSZ_ENABLE_CFG 0x14 +#define RSZ_VL_LUMA_HOR 0x08 +#define RSZ_VL_LUMA_VER 0x0c +#define RSZ_VL_CHROMA_HOR 0x10 +#define RSZ_VL_CHROMA_VER 0x14 +#define RSZ_VL_CTRL_CFG 0x18 +#define RSZ_VL_FMT_SHIFT 3 +#define RSZ_VL_FMT_MASK (0x3 << RSZ_VL_FMT_SHIFT) +#define RSZ_VL_FMT_YCBCR420 (0x0 << RSZ_VL_FMT_SHIFT) +#define RSZ_VL_FMT_YCBCR422 (0x1 << RSZ_VL_FMT_SHIFT) +#define RSZ_VL_FMT_YCBCR444 (0x2 << RSZ_VL_FMT_SHIFT) +#define RSZ_VL_ENABLE_CFG 0x1c + #define RSZ_VER_SHIFT 16 #define RSZ_VER_MASK (0xffff << RSZ_VER_SHIFT) #define RSZ_HOR_SHIFT 0 @@ -77,6 +120,14 @@ #define RSZ_VER(x) (((x) << RSZ_VER_SHIFT) & RSZ_VER_MASK) #define RSZ_HOR(x) (((x) << RSZ_HOR_SHIFT) & RSZ_HOR_MASK) +#define RSZ_DATA_STEP_SHIFT 16 +#define RSZ_DATA_STEP_MASK (0xffff << RSZ_DATA_STEP_SHIFT) +#define RSZ_PARA_STEP_SHIFT 0 +#define RSZ_PARA_STEP_MASK (0xffff << RSZ_PARA_STEP_SHIFT) + +#define RSZ_DATA_STEP(x) (((x) << RSZ_DATA_STEP_SHIFT) & RSZ_DATA_STEP_MASK) +#define RSZ_PARA_STEP(x) (((x) << RSZ_PARA_STEP_SHIFT) & RSZ_PARA_STEP_MASK) + /* HBSC registers */ #define HBSC_SATURATION 0x00 #define HBSC_HUE 0x04 diff --git a/drivers/gpu/drm/zte/zx_vou.c b/drivers/gpu/drm/zte/zx_vou.c index 73fe15c17c32..8ca9c4bdeeaf 100644 --- a/drivers/gpu/drm/zte/zx_vou.c +++ b/drivers/gpu/drm/zte/zx_vou.c @@ -93,10 +93,38 @@ struct zx_crtc { const struct zx_crtc_bits *bits; enum vou_chn_type chn_type; struct clk *pixclk; + u32 overlay_bitmap; }; #define to_zx_crtc(x) container_of(x, struct zx_crtc, crtc) +struct zx_vl_bits { + u32 enable; + u32 chnsel; + u32 clksel; +}; + +static const struct zx_vl_bits zx_vl_bits[VL_NUM] = { + { + .enable = OSD_CTRL0_VL0_EN, + .chnsel = OSD_CTRL0_VL0_SEL, + .clksel = VOU_CLK_VL0_SEL, + }, { + .enable = OSD_CTRL0_VL1_EN, + .chnsel = OSD_CTRL0_VL1_SEL, + .clksel = VOU_CLK_VL1_SEL, + }, { + .enable = OSD_CTRL0_VL2_EN, + .chnsel = OSD_CTRL0_VL2_SEL, + .clksel = VOU_CLK_VL2_SEL, + }, +}; + +struct zx_overlay { + struct drm_plane *plane; + const struct zx_vl_bits *bits; +}; + struct zx_vou_hw { struct device *dev; void __iomem *osd; @@ -110,6 +138,7 @@ struct zx_vou_hw { struct clk *aux_clk; struct zx_crtc *main_crtc; struct zx_crtc *aux_crtc; + struct zx_overlay overlays[VL_NUM]; }; static inline struct zx_vou_hw *crtc_to_vou(struct drm_crtc *crtc) @@ -404,6 +433,112 @@ void zx_vou_disable_vblank(struct drm_device *drm, unsigned int pipe) zcrtc->bits->int_frame_mask, 0); } +static int zx_overlay_find_vl_idx(struct drm_plane *plane, + struct zx_vou_hw *vou) +{ + int i; + + for (i = 0; i < VL_NUM; i++) { + if (vou->overlays[i].plane == plane) + break; + } + + if (i == VL_NUM) { + DRM_DEV_ERROR(vou->dev, "failed to find VL\n"); + return -EINVAL; + } + + return i; +} + +void zx_overlay_enable(struct drm_plane *plane) +{ + struct zx_crtc *zcrtc = to_zx_crtc(plane->state->crtc); + struct zx_vou_hw *vou = zcrtc->vou; + const struct zx_vl_bits *bits; + int idx; + + idx = zx_overlay_find_vl_idx(plane, vou); + if (idx < 0) + return; + + bits = vou->overlays[idx].bits; + zcrtc->overlay_bitmap |= 1 << idx; + + if (zcrtc->chn_type == VOU_CHN_MAIN) { + zx_writel_mask(vou->osd + OSD_CTRL0, bits->chnsel, 0); + zx_writel_mask(vou->vouctl + VOU_CLK_SEL, bits->clksel, 0); + } else { + zx_writel_mask(vou->osd + OSD_CTRL0, bits->chnsel, + bits->chnsel); + zx_writel_mask(vou->vouctl + VOU_CLK_SEL, bits->clksel, + bits->clksel); + } + + zx_writel_mask(vou->osd + OSD_CTRL0, bits->enable, bits->enable); +} + +void zx_overlay_disable(struct drm_plane *plane) +{ + struct zx_crtc *zcrtc = to_zx_crtc(plane->crtc); + struct zx_vou_hw *vou = zcrtc->vou; + const struct zx_vl_bits *bits; + int idx; + + idx = zx_overlay_find_vl_idx(plane, vou); + if (idx < 0) + return; + + bits = vou->overlays[idx].bits; + zcrtc->overlay_bitmap &= ~(1 << idx); + + zx_writel_mask(vou->osd + OSD_CTRL0, bits->enable, 0); +} + +static void zx_overlay_init(struct drm_device *drm, struct zx_vou_hw *vou) +{ + struct device *dev = vou->dev; + struct drm_plane *plane; + struct zx_layer_data data; + int i; + + /* + * VL0 has some quirks on scaling support which need special handling. + * Let's leave it out for now. + */ + for (i = 1; i < VL_NUM; i++) { + data.layer = vou->osd + OSD_VL_OFFSET(i); + data.hbsc = vou->osd + HBSC_VL_OFFSET(i); + data.rsz = vou->otfppu + RSZ_VL_OFFSET(i); + + plane = zx_plane_init(drm, dev, &data, DRM_PLANE_TYPE_OVERLAY); + if (IS_ERR(plane)) { + DRM_DEV_ERROR(dev, "failed to init overlay %d\n", i); + continue; + } + + vou->overlays[i].plane = plane; + vou->overlays[i].bits = &zx_vl_bits[i]; + } +} + +static inline void zx_osd_int_update(struct zx_crtc *zcrtc) +{ + u32 bitmap = zcrtc->overlay_bitmap; + int i; + + vou_chn_set_update(zcrtc); + zx_plane_set_update(zcrtc->primary); + + if (bitmap) { + for (i = 0; i < VL_NUM; i++) { + if ((bitmap & (1 << i)) == 0) + continue; + zx_plane_set_update(zcrtc->vou->overlays[i].plane); + } + } +} + static irqreturn_t vou_irq_handler(int irq, void *dev_id) { struct zx_vou_hw *vou = dev_id; @@ -423,15 +558,11 @@ static irqreturn_t vou_irq_handler(int irq, void *dev_id) state = zx_readl(vou->osd + OSD_INT_STA); zx_writel(vou->osd + OSD_INT_CLRSTA, state); - if (state & OSD_INT_MAIN_UPT) { - vou_chn_set_update(vou->main_crtc); - zx_plane_set_update(vou->main_crtc->primary); - } + if (state & OSD_INT_MAIN_UPT) + zx_osd_int_update(vou->main_crtc); - if (state & OSD_INT_AUX_UPT) { - vou_chn_set_update(vou->aux_crtc); - zx_plane_set_update(vou->aux_crtc->primary); - } + if (state & OSD_INT_AUX_UPT) + zx_osd_int_update(vou->aux_crtc); if (state & OSD_INT_ERROR) DRM_DEV_ERROR(vou->dev, "OSD ERROR: 0x%08x!\n", state); @@ -611,6 +742,8 @@ static int zx_crtc_bind(struct device *dev, struct device *master, void *data) goto disable_ppu_clk; } + zx_overlay_init(drm, vou); + return 0; disable_ppu_clk: diff --git a/drivers/gpu/drm/zte/zx_vou.h b/drivers/gpu/drm/zte/zx_vou.h index 349e06cd86f4..1559c1f79db7 100644 --- a/drivers/gpu/drm/zte/zx_vou.h +++ b/drivers/gpu/drm/zte/zx_vou.h @@ -43,4 +43,7 @@ struct vou_inf { int zx_vou_enable_vblank(struct drm_device *drm, unsigned int pipe); void zx_vou_disable_vblank(struct drm_device *drm, unsigned int pipe); +void zx_overlay_enable(struct drm_plane *plane); +void zx_overlay_disable(struct drm_plane *plane); + #endif /* __ZX_VOU_H__ */ diff --git a/drivers/gpu/drm/zte/zx_vou_regs.h b/drivers/gpu/drm/zte/zx_vou_regs.h index f44e7a4ae441..193c1ce01fe7 100644 --- a/drivers/gpu/drm/zte/zx_vou_regs.h +++ b/drivers/gpu/drm/zte/zx_vou_regs.h @@ -22,6 +22,15 @@ #define AUX_HBSC_OFFSET 0x860 #define AUX_RSZ_OFFSET 0x800 +#define OSD_VL0_OFFSET 0x040 +#define OSD_VL_OFFSET(i) (OSD_VL0_OFFSET + 0x050 * (i)) + +#define HBSC_VL0_OFFSET 0x760 +#define HBSC_VL_OFFSET(i) (HBSC_VL0_OFFSET + 0x040 * (i)) + +#define RSZ_VL1_U0 0xa00 +#define RSZ_VL_OFFSET(i) (RSZ_VL1_U0 + 0x200 * (i)) + /* OSD (GPC_GLOBAL) registers */ #define OSD_INT_STA 0x04 #define OSD_INT_CLRSTA 0x08 @@ -42,6 +51,12 @@ ) #define OSD_INT_ENABLE (OSD_INT_ERROR | OSD_INT_AUX_UPT | OSD_INT_MAIN_UPT) #define OSD_CTRL0 0x10 +#define OSD_CTRL0_VL0_EN BIT(13) +#define OSD_CTRL0_VL0_SEL BIT(12) +#define OSD_CTRL0_VL1_EN BIT(11) +#define OSD_CTRL0_VL1_SEL BIT(10) +#define OSD_CTRL0_VL2_EN BIT(9) +#define OSD_CTRL0_VL2_SEL BIT(8) #define OSD_CTRL0_GL0_EN BIT(7) #define OSD_CTRL0_GL0_SEL BIT(6) #define OSD_CTRL0_GL1_EN BIT(5) @@ -146,6 +161,9 @@ #define VOU_INF_DATA_SEL 0x08 #define VOU_SOFT_RST 0x14 #define VOU_CLK_SEL 0x18 +#define VOU_CLK_VL2_SEL BIT(8) +#define VOU_CLK_VL1_SEL BIT(7) +#define VOU_CLK_VL0_SEL BIT(6) #define VOU_CLK_GL1_SEL BIT(5) #define VOU_CLK_GL0_SEL BIT(4) #define VOU_CLK_REQEN 0x20 -- 1.9.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Shawn Guo Subject: [PATCH v2] drm: zte: add overlay plane support Date: Tue, 20 Dec 2016 20:09:55 +0800 Message-ID: <1482235795-6223-1-git-send-email-shawnguo@kernel.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail.kernel.org (mail.kernel.org [198.145.29.136]) by gabe.freedesktop.org (Postfix) with ESMTPS id 09AF96E981 for ; Tue, 20 Dec 2016 12:10:43 +0000 (UTC) List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: dri-devel@lists.freedesktop.org Cc: Daniel Vetter , Baoyou Xie , linux-arm-kernel@lists.infradead.org, Jun Nie , Shawn Guo List-Id: dri-devel@lists.freedesktop.org RnJvbTogU2hhd24gR3VvIDxzaGF3bi5ndW9AbGluYXJvLm9yZz4KCkl0IGVuYWJsZXMgVk9VIFZM IChWaWRlbyBMYXllcikgdG8gc3VwcG9ydCBvdmVybGF5IHBsYW5lIHdpdGggc2NhbGluZwpmdW5j dGlvbi4gIFZMMCBoYXMgc29tZSBxdWlya3Mgb24gc2NhbGluZyBzdXBwb3J0LiAgV2UgY2hvc2Ug dG8gc2tpcCBpdAphbmQgb25seSBhZGRzIFZMMSBhbmQgVkwyIGludG8gRFJNIGNvcmUgZm9yIG5v dy4KClNpZ25lZC1vZmYtYnk6IFNoYXduIEd1byA8c2hhd24uZ3VvQGxpbmFyby5vcmc+Ci0tLQpD aGFuZ2VzIGZvciB2MjoKIC0gVXNlIGNsaXBwZWQgY29vcmRpbmF0ZXMgZm9yIG92ZXJsYXkgcG9z aXRpb24gY2FsY3VsYXRpb24KCiBkcml2ZXJzL2dwdS9kcm0venRlL3p4X3BsYW5lLmMgICAgICB8 IDI5MyArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0KIGRyaXZlcnMvZ3B1L2Ry bS96dGUvenhfcGxhbmVfcmVncy5oIHwgIDUxICsrKysrKysKIGRyaXZlcnMvZ3B1L2RybS96dGUv enhfdm91LmMgICAgICAgIHwgMTQ5ICsrKysrKysrKysrKysrKysrLQogZHJpdmVycy9ncHUvZHJt L3p0ZS96eF92b3UuaCAgICAgICAgfCAgIDMgKwogZHJpdmVycy9ncHUvZHJtL3p0ZS96eF92b3Vf cmVncy5oICAgfCAgMTggKysrCiA1IGZpbGVzIGNoYW5nZWQsIDQ5NyBpbnNlcnRpb25zKCspLCAx NyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0venRlL3p4X3BsYW5l LmMgYi9kcml2ZXJzL2dwdS9kcm0venRlL3p4X3BsYW5lLmMKaW5kZXggNTQ2ZWI5MmE5NGU4Li44 Y2Q3Y2Y3MWIyYjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS96dGUvenhfcGxhbmUuYwor KysgYi9kcml2ZXJzL2dwdS9kcm0venRlL3p4X3BsYW5lLmMKQEAgLTQwLDYgKzQwLDI2OSBAQCBz dHJ1Y3QgenhfcGxhbmUgewogCURSTV9GT1JNQVRfQVJHQjQ0NDQsCiB9OwogCitzdGF0aWMgY29u c3QgdWludDMyX3QgdmxfZm9ybWF0c1tdID0geworCURSTV9GT1JNQVRfTlYxMiwJLyogU2VtaS1w bGFuYXIgWVVWNDIwICovCisJRFJNX0ZPUk1BVF9ZVVY0MjAsCS8qIFBsYW5hciBZVVY0MjAgKi8K KwlEUk1fRk9STUFUX1lVWVYsCS8qIFBhY2tlZCBZVVY0MjIgKi8KKwlEUk1fRk9STUFUX1lWWVUs CisJRFJNX0ZPUk1BVF9VWVZZLAorCURSTV9GT1JNQVRfVllVWSwKKwlEUk1fRk9STUFUX1lVVjQ0 NCwJLyogWVVWNDQ0IDhiaXQgKi8KKwkvKgorCSAqIFRPRE86IGFkZCBmb3JtYXRzIGJlbG93IHRo YXQgSFcgc3VwcG9ydHM6CisJICogIC0gWVVWNDIwIFAwMTAKKwkgKiAgLSBZVVY0MjAgSGFudHJv CisJICogIC0gWVVWNDQ0IDEwYml0CisJICovCit9OworCisjZGVmaW5lIEZSQUNfMTZfMTYobXVs dCwgZGl2KSAgICAoKChtdWx0KSA8PCAxNikgLyAoZGl2KSkKKworc3RhdGljIGludCB6eF92bF9w bGFuZV9hdG9taWNfY2hlY2soc3RydWN0IGRybV9wbGFuZSAqcGxhbmUsCisJCQkJICAgIHN0cnVj dCBkcm1fcGxhbmVfc3RhdGUgKnBsYW5lX3N0YXRlKQoreworCXN0cnVjdCBkcm1fZnJhbWVidWZm ZXIgKmZiID0gcGxhbmVfc3RhdGUtPmZiOworCXN0cnVjdCBkcm1fY3J0YyAqY3J0YyA9IHBsYW5l X3N0YXRlLT5jcnRjOworCXN0cnVjdCBkcm1fY3J0Y19zdGF0ZSAqY3J0Y19zdGF0ZTsKKwlzdHJ1 Y3QgZHJtX3JlY3QgY2xpcDsKKwlpbnQgbWluX3NjYWxlID0gRlJBQ18xNl8xNigxLCA4KTsKKwlp bnQgbWF4X3NjYWxlID0gRlJBQ18xNl8xNig4LCAxKTsKKworCWlmICghY3J0YyB8fCAhZmIpCisJ CXJldHVybiAwOworCisJY3J0Y19zdGF0ZSA9IGRybV9hdG9taWNfZ2V0X2V4aXN0aW5nX2NydGNf c3RhdGUocGxhbmVfc3RhdGUtPnN0YXRlLAorCQkJCQkJCWNydGMpOworCWlmIChXQVJOX09OKCFj cnRjX3N0YXRlKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwkvKiBub3RoaW5nIHRvIGNoZWNrIHdo ZW4gZGlzYWJsaW5nIG9yIGRpc2FibGVkICovCisJaWYgKCFjcnRjX3N0YXRlLT5lbmFibGUpCisJ CXJldHVybiAwOworCisJLyogcGxhbmUgbXVzdCBiZSBlbmFibGVkICovCisJaWYgKCFwbGFuZV9z dGF0ZS0+Y3J0YykKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwljbGlwLngxID0gMDsKKwljbGlwLnkx ID0gMDsKKwljbGlwLngyID0gY3J0Y19zdGF0ZS0+YWRqdXN0ZWRfbW9kZS5oZGlzcGxheTsKKwlj bGlwLnkyID0gY3J0Y19zdGF0ZS0+YWRqdXN0ZWRfbW9kZS52ZGlzcGxheTsKKworCXJldHVybiBk cm1fcGxhbmVfaGVscGVyX2NoZWNrX3N0YXRlKHBsYW5lX3N0YXRlLCAmY2xpcCwKKwkJCQkJICAg IG1pbl9zY2FsZSwgbWF4X3NjYWxlLAorCQkJCQkgICAgdHJ1ZSwgdHJ1ZSk7Cit9CisKK3N0YXRp YyB1MzIgenhfdmxfZ2V0X2ZtdCh1aW50MzJfdCBmb3JtYXQpCit7CisJdTMyIHZhbCA9IDA7CisK Kwlzd2l0Y2ggKGZvcm1hdCkgeworCWNhc2UgRFJNX0ZPUk1BVF9OVjEyOgorCQl2YWwgPSBWTF9G TVRfWVVWNDIwOworCQlicmVhazsKKwljYXNlIERSTV9GT1JNQVRfWVVWNDIwOgorCQl2YWwgPSBW TF9ZVVY0MjBfUExBTkFSIHwgVkxfRk1UX1lVVjQyMDsKKwkJYnJlYWs7CisJY2FzZSBEUk1fRk9S TUFUX1lVWVY6CisJCXZhbCA9IFZMX1lVVjQyMl9ZVVlWIHwgVkxfRk1UX1lVVjQyMjsKKwkJYnJl YWs7CisJY2FzZSBEUk1fRk9STUFUX1lWWVU6CisJCXZhbCA9IFZMX1lVVjQyMl9ZVllVIHwgVkxf Rk1UX1lVVjQyMjsKKwkJYnJlYWs7CisJY2FzZSBEUk1fRk9STUFUX1VZVlk6CisJCXZhbCA9IFZM X1lVVjQyMl9VWVZZIHwgVkxfRk1UX1lVVjQyMjsKKwkJYnJlYWs7CisJY2FzZSBEUk1fRk9STUFU X1ZZVVk6CisJCXZhbCA9IFZMX1lVVjQyMl9WWVVZIHwgVkxfRk1UX1lVVjQyMjsKKwkJYnJlYWs7 CisJY2FzZSBEUk1fRk9STUFUX1lVVjQ0NDoKKwkJdmFsID0gVkxfRk1UX1lVVjQ0NF84QklUOwor CQlicmVhazsKKwlkZWZhdWx0OgorCQlXQVJOX09OQ0UoMSwgImludmFsaWQgcGl4ZWwgZm9ybWF0 ICVkXG4iLCBmb3JtYXQpOworCX0KKworCXJldHVybiB2YWw7Cit9CisKK3N0YXRpYyBpbmxpbmUg dm9pZCB6eF92bF9zZXRfdXBkYXRlKHN0cnVjdCB6eF9wbGFuZSAqenBsYW5lKQoreworCXZvaWQg X19pb21lbSAqbGF5ZXIgPSB6cGxhbmUtPmxheWVyOworCisJenhfd3JpdGVsX21hc2sobGF5ZXIg KyBWTF9DVFJMMCwgVkxfVVBEQVRFLCBWTF9VUERBVEUpOworfQorCitzdGF0aWMgaW5saW5lIHZv aWQgenhfdmxfcnN6X3NldF91cGRhdGUoc3RydWN0IHp4X3BsYW5lICp6cGxhbmUpCit7CisJenhf d3JpdGVsKHpwbGFuZS0+cnN6ICsgUlNaX1ZMX0VOQUJMRV9DRkcsIDEpOworfQorCitzdGF0aWMg dTMyIHp4X3ZsX3Jzel9nZXRfZm10KHVpbnQzMl90IGZvcm1hdCkKK3sKKwl1MzIgdmFsID0gMDsK KworCXN3aXRjaCAoZm9ybWF0KSB7CisJY2FzZSBEUk1fRk9STUFUX05WMTI6CisJY2FzZSBEUk1f Rk9STUFUX1lVVjQyMDoKKwkJdmFsID0gUlNaX1ZMX0ZNVF9ZQ0JDUjQyMDsKKwkJYnJlYWs7CisJ Y2FzZSBEUk1fRk9STUFUX1lVWVY6CisJY2FzZSBEUk1fRk9STUFUX1lWWVU6CisJY2FzZSBEUk1f Rk9STUFUX1VZVlk6CisJY2FzZSBEUk1fRk9STUFUX1ZZVVk6CisJCXZhbCA9IFJTWl9WTF9GTVRf WUNCQ1I0MjI7CisJCWJyZWFrOworCWNhc2UgRFJNX0ZPUk1BVF9ZVVY0NDQ6CisJCXZhbCA9IFJT Wl9WTF9GTVRfWUNCQ1I0NDQ7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCVdBUk5fT05DRSgxLCAi aW52YWxpZCBwaXhlbCBmb3JtYXQgJWRcbiIsIGZvcm1hdCk7CisJfQorCisJcmV0dXJuIHZhbDsK K30KKworc3RhdGljIGlubGluZSB1MzIgcnN6X3N0ZXBfdmFsdWUodTMyIHNyYywgdTMyIGRzdCkK K3sKKwl1MzIgdmFsID0gMDsKKworCWlmIChzcmMgPT0gZHN0KQorCQl2YWwgPSAwOworCWVsc2Ug aWYgKHNyYyA8IGRzdCkKKwkJdmFsID0gUlNaX1BBUkFfU1RFUCgoc3JjIDw8IDE2KSAvIGRzdCk7 CisJZWxzZSBpZiAoc3JjID4gZHN0KQorCQl2YWwgPSBSU1pfREFUQV9TVEVQKHNyYyAvIGRzdCkg fAorCQkgICAgICBSU1pfUEFSQV9TVEVQKCgoc3JjIDw8IDE2KSAvIGRzdCkgJiAweGZmZmYpOwor CisJcmV0dXJuIHZhbDsKK30KKworc3RhdGljIHZvaWQgenhfdmxfcnN6X3NldHVwKHN0cnVjdCB6 eF9wbGFuZSAqenBsYW5lLCB1aW50MzJfdCBmb3JtYXQsCisJCQkgICAgdTMyIHNyY193LCB1MzIg c3JjX2gsIHUzMiBkc3RfdywgdTMyIGRzdF9oKQoreworCXZvaWQgX19pb21lbSAqcnN6ID0genBs YW5lLT5yc3o7CisJdTMyIHNyY19jaHJvbWFfdyA9IHNyY193OworCXUzMiBzcmNfY2hyb21hX2gg PSBzcmNfaDsKKwl1MzIgZm10OworCisJLyogU2V0IHVwIHNvdXJjZSBhbmQgZGVzdGluYXRpb24g cmVzb2x1dGlvbiAqLworCXp4X3dyaXRlbChyc3ogKyBSU1pfU1JDX0NGRywgUlNaX1ZFUihzcmNf aCAtIDEpIHwgUlNaX0hPUihzcmNfdyAtIDEpKTsKKwl6eF93cml0ZWwocnN6ICsgUlNaX0RFU1Rf Q0ZHLCBSU1pfVkVSKGRzdF9oIC0gMSkgfCBSU1pfSE9SKGRzdF93IC0gMSkpOworCisJLyogQ29u ZmlndXJlIGRhdGEgZm9ybWF0IGZvciBWTCBSU1ogKi8KKwlmbXQgPSB6eF92bF9yc3pfZ2V0X2Zt dChmb3JtYXQpOworCXp4X3dyaXRlbF9tYXNrKHJzeiArIFJTWl9WTF9DVFJMX0NGRywgUlNaX1ZM X0ZNVF9NQVNLLCBmbXQpOworCisJLyogQ2FsY3VsYXRlIENocm9tYSBoZWlndGggYW5kIHdpZHRo ICovCisJaWYgKGZtdCA9PSBSU1pfVkxfRk1UX1lDQkNSNDIwKSB7CisJCXNyY19jaHJvbWFfdyA9 IHNyY193ID4+IDE7CisJCXNyY19jaHJvbWFfaCA9IHNyY19oID4+IDE7CisJfSBlbHNlIGlmIChm bXQgPT0gUlNaX1ZMX0ZNVF9ZQ0JDUjQyMikgeworCQlzcmNfY2hyb21hX3cgPSBzcmNfdyA+PiAx OworCX0KKworCS8qIFNldCB1cCBMdW1hIGFuZCBDaHJvbWEgc3RlcCByZWdpc3RlcnMgKi8KKwl6 eF93cml0ZWwocnN6ICsgUlNaX1ZMX0xVTUFfSE9SLCByc3pfc3RlcF92YWx1ZShzcmNfdywgZHN0 X3cpKTsKKwl6eF93cml0ZWwocnN6ICsgUlNaX1ZMX0xVTUFfVkVSLCByc3pfc3RlcF92YWx1ZShz cmNfaCwgZHN0X2gpKTsKKwl6eF93cml0ZWwocnN6ICsgUlNaX1ZMX0NIUk9NQV9IT1IsIHJzel9z dGVwX3ZhbHVlKHNyY19jaHJvbWFfdywgZHN0X3cpKTsKKwl6eF93cml0ZWwocnN6ICsgUlNaX1ZM X0NIUk9NQV9WRVIsIHJzel9zdGVwX3ZhbHVlKHNyY19jaHJvbWFfaCwgZHN0X2gpKTsKKworCXp4 X3ZsX3Jzel9zZXRfdXBkYXRlKHpwbGFuZSk7Cit9CisKK3N0YXRpYyB2b2lkIHp4X3ZsX3BsYW5l X2F0b21pY191cGRhdGUoc3RydWN0IGRybV9wbGFuZSAqcGxhbmUsCisJCQkJICAgICAgc3RydWN0 IGRybV9wbGFuZV9zdGF0ZSAqb2xkX3N0YXRlKQoreworCXN0cnVjdCB6eF9wbGFuZSAqenBsYW5l ID0gdG9fenhfcGxhbmUocGxhbmUpOworCXN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKnN0YXRlID0g cGxhbmUtPnN0YXRlOworCXN0cnVjdCBkcm1fZnJhbWVidWZmZXIgKmZiID0gc3RhdGUtPmZiOwor CXN0cnVjdCBkcm1fcmVjdCAqc3JjID0gJnN0YXRlLT5zcmM7CisJc3RydWN0IGRybV9yZWN0ICpk c3QgPSAmc3RhdGUtPmRzdDsKKwlzdHJ1Y3QgZHJtX2dlbV9jbWFfb2JqZWN0ICpjbWFfb2JqOwor CXZvaWQgX19pb21lbSAqbGF5ZXIgPSB6cGxhbmUtPmxheWVyOworCXZvaWQgX19pb21lbSAqaGJz YyA9IHpwbGFuZS0+aGJzYzsKKwl2b2lkIF9faW9tZW0gKnBhZGRyX3JlZzsKKwlkbWFfYWRkcl90 IHBhZGRyOworCXUzMiBzcmNfeCwgc3JjX3ksIHNyY193LCBzcmNfaDsKKwl1MzIgZHN0X3gsIGRz dF95LCBkc3RfdywgZHN0X2g7CisJdWludDMyX3QgZm9ybWF0OworCXUzMiBmbXQ7CisJaW50IG51 bV9wbGFuZXM7CisJaW50IGk7CisKKwlpZiAoIWZiKQorCQlyZXR1cm47CisKKwlmb3JtYXQgPSBm Yi0+cGl4ZWxfZm9ybWF0OworCisJc3JjX3ggPSBzcmMtPngxID4+IDE2OworCXNyY195ID0gc3Jj LT55MSA+PiAxNjsKKwlzcmNfdyA9IGRybV9yZWN0X3dpZHRoKHNyYykgPj4gMTY7CisJc3JjX2gg PSBkcm1fcmVjdF9oZWlnaHQoc3JjKSA+PiAxNjsKKworCWRzdF94ID0gZHN0LT54MTsKKwlkc3Rf eSA9IGRzdC0+eTE7CisJZHN0X3cgPSBkcm1fcmVjdF93aWR0aChkc3QpOworCWRzdF9oID0gZHJt X3JlY3RfaGVpZ2h0KGRzdCk7CisKKwkvKiBTZXQgdXAgZGF0YSBhZGRyZXNzIHJlZ2lzdGVycyBm b3IgWSwgQ2IgYW5kIENyIHBsYW5lcyAqLworCW51bV9wbGFuZXMgPSBkcm1fZm9ybWF0X251bV9w bGFuZXMoZm9ybWF0KTsKKwlwYWRkcl9yZWcgPSBsYXllciArIFZMX1k7CisJZm9yIChpID0gMDsg aSA8IG51bV9wbGFuZXM7IGkrKykgeworCQljbWFfb2JqID0gZHJtX2ZiX2NtYV9nZXRfZ2VtX29i aihmYiwgaSk7CisJCXBhZGRyID0gY21hX29iai0+cGFkZHIgKyBmYi0+b2Zmc2V0c1tpXTsKKwkJ cGFkZHIgKz0gc3JjX3kgKiBmYi0+cGl0Y2hlc1tpXTsKKwkJcGFkZHIgKz0gc3JjX3ggKiBkcm1f Zm9ybWF0X3BsYW5lX2NwcChmb3JtYXQsIGkpOworCQl6eF93cml0ZWwocGFkZHJfcmVnLCBwYWRk cik7CisJCXBhZGRyX3JlZyArPSA0OworCX0KKworCS8qIFNldCB1cCBzb3VyY2UgaGVpZ2h0L3dp ZHRoIHJlZ2lzdGVyICovCisJenhfd3JpdGVsKGxheWVyICsgVkxfU1JDX1NJWkUsIEdMX1NSQ19X KHNyY193KSB8IEdMX1NSQ19IKHNyY19oKSk7CisKKwkvKiBTZXQgdXAgc3RhcnQgcG9zaXRpb24g cmVnaXN0ZXIgKi8KKwl6eF93cml0ZWwobGF5ZXIgKyBWTF9QT1NfU1RBUlQsIEdMX1BPU19YKGRz dF94KSB8IEdMX1BPU19ZKGRzdF95KSk7CisKKwkvKiBTZXQgdXAgZW5kIHBvc2l0aW9uIHJlZ2lz dGVyICovCisJenhfd3JpdGVsKGxheWVyICsgVkxfUE9TX0VORCwKKwkJICBHTF9QT1NfWChkc3Rf eCArIGRzdF93KSB8IEdMX1BPU19ZKGRzdF95ICsgZHN0X2gpKTsKKworCS8qIFN0cmlkZXMgb2Yg Q2IgYW5kIENyIHBsYW5lcyBzaG91bGQgYmUgaWRlbnRpY2FsICovCisJenhfd3JpdGVsKGxheWVy ICsgVkxfU1RSSURFLCBMVU1BX1NUUklERShmYi0+cGl0Y2hlc1swXSkgfAorCQkgIENIUk9NQV9T VFJJREUoZmItPnBpdGNoZXNbMV0pKTsKKworCS8qIFNldCB1cCB2aWRlbyBsYXllciBkYXRhIGZv cm1hdCAqLworCWZtdCA9IHp4X3ZsX2dldF9mbXQoZm9ybWF0KTsKKwl6eF93cml0ZWwobGF5ZXIg KyBWTF9DVFJMMSwgZm10KTsKKworCS8qIEFsd2F5cyB1c2Ugc2NhbGVyIHNpbmNlIGl0IGV4aXN0 cyAoc2V0IGZvciBub3QgYnlwYXNzKSAqLworCXp4X3dyaXRlbF9tYXNrKGxheWVyICsgVkxfQ1RS TDIsIFZMX1NDQUxFUl9CWVBBU1NfTU9ERSwKKwkJICAgICAgIFZMX1NDQUxFUl9CWVBBU1NfTU9E RSk7CisKKwl6eF92bF9yc3pfc2V0dXAoenBsYW5lLCBmb3JtYXQsIHNyY193LCBzcmNfaCwgZHN0 X3csIGRzdF9oKTsKKworCS8qIEVuYWJsZSBIQlNDIGJsb2NrICovCisJenhfd3JpdGVsX21hc2so aGJzYyArIEhCU0NfQ1RSTDAsIEhCU0NfQ1RSTF9FTiwgSEJTQ19DVFJMX0VOKTsKKworCXp4X292 ZXJsYXlfZW5hYmxlKHBsYW5lKTsKKworCXp4X3ZsX3NldF91cGRhdGUoenBsYW5lKTsKK30KKwor c3RhdGljIHZvaWQgenhfdmxfcGxhbmVfYXRvbWljX2Rpc2FibGUoc3RydWN0IGRybV9wbGFuZSAq cGxhbmUsCisJCQkJICAgICAgIHN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKm9sZF9zdGF0ZSkKK3sK Kwl6eF9vdmVybGF5X2Rpc2FibGUocGxhbmUpOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGRy bV9wbGFuZV9oZWxwZXJfZnVuY3MgenhfdmxfcGxhbmVfaGVscGVyX2Z1bmNzID0geworCS5hdG9t aWNfY2hlY2sgPSB6eF92bF9wbGFuZV9hdG9taWNfY2hlY2ssCisJLmF0b21pY191cGRhdGUgPSB6 eF92bF9wbGFuZV9hdG9taWNfdXBkYXRlLAorCS5hdG9taWNfZGlzYWJsZSA9IHp4X3ZsX3BsYW5l X2F0b21pY19kaXNhYmxlLAorfTsKKwogc3RhdGljIGludCB6eF9nbF9wbGFuZV9hdG9taWNfY2hl Y2soc3RydWN0IGRybV9wbGFuZSAqcGxhbmUsCiAJCQkJICAgIHN0cnVjdCBkcm1fcGxhbmVfc3Rh dGUgKnBsYW5lX3N0YXRlKQogewpAQCAtMTA3LDE0ICszNzAsNiBAQCBzdGF0aWMgaW5saW5lIHZv aWQgenhfZ2xfcnN6X3NldF91cGRhdGUoc3RydWN0IHp4X3BsYW5lICp6cGxhbmUpCiAJenhfd3Jp dGVsKHpwbGFuZS0+cnN6ICsgUlNaX0VOQUJMRV9DRkcsIDEpOwogfQogCi12b2lkIHp4X3BsYW5l X3NldF91cGRhdGUoc3RydWN0IGRybV9wbGFuZSAqcGxhbmUpCi17Ci0Jc3RydWN0IHp4X3BsYW5l ICp6cGxhbmUgPSB0b196eF9wbGFuZShwbGFuZSk7Ci0KLQl6eF9nbF9yc3pfc2V0X3VwZGF0ZSh6 cGxhbmUpOwotCXp4X2dsX3NldF91cGRhdGUoenBsYW5lKTsKLX0KLQogc3RhdGljIHZvaWQgenhf Z2xfcnN6X3NldHVwKHN0cnVjdCB6eF9wbGFuZSAqenBsYW5lLCB1MzIgc3JjX3csIHUzMiBzcmNf aCwKIAkJCSAgICB1MzIgZHN0X3csIHUzMiBkc3RfaCkKIHsKQEAgLTIzMCw2ICs0ODUsMjQgQEAg c3RhdGljIHZvaWQgenhfcGxhbmVfZGVzdHJveShzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSkKIAku YXRvbWljX2Rlc3Ryb3lfc3RhdGUgPSBkcm1fYXRvbWljX2hlbHBlcl9wbGFuZV9kZXN0cm95X3N0 YXRlLAogfTsKIAordm9pZCB6eF9wbGFuZV9zZXRfdXBkYXRlKHN0cnVjdCBkcm1fcGxhbmUgKnBs YW5lKQoreworCXN0cnVjdCB6eF9wbGFuZSAqenBsYW5lID0gdG9fenhfcGxhbmUocGxhbmUpOwor CisJc3dpdGNoIChwbGFuZS0+dHlwZSkgeworCWNhc2UgRFJNX1BMQU5FX1RZUEVfUFJJTUFSWToK KwkJenhfZ2xfcnN6X3NldF91cGRhdGUoenBsYW5lKTsKKwkJenhfZ2xfc2V0X3VwZGF0ZSh6cGxh bmUpOworCQlicmVhazsKKwljYXNlIERSTV9QTEFORV9UWVBFX09WRVJMQVk6CisJCXp4X3ZsX3Jz el9zZXRfdXBkYXRlKHpwbGFuZSk7CisJCXp4X3ZsX3NldF91cGRhdGUoenBsYW5lKTsKKwkJYnJl YWs7CisJZGVmYXVsdDoKKwkJV0FSTl9PTkNFKDEsICJ1bnN1cHBvcnRlZCBwbGFuZSB0eXBlICVk XG4iLCBwbGFuZS0+dHlwZSk7CisJfQorfQorCiBzdGF0aWMgdm9pZCB6eF9wbGFuZV9oYnNjX2lu aXQoc3RydWN0IHp4X3BsYW5lICp6cGxhbmUpCiB7CiAJdm9pZCBfX2lvbWVtICpoYnNjID0genBs YW5lLT5oYnNjOwpAQCAtMjc5LDcgKzU1Miw5IEBAIHN0cnVjdCBkcm1fcGxhbmUgKnp4X3BsYW5l X2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRybSwgc3RydWN0IGRldmljZSAqZGV2LAogCQlmb3Jt YXRfY291bnQgPSBBUlJBWV9TSVpFKGdsX2Zvcm1hdHMpOwogCQlicmVhazsKIAljYXNlIERSTV9Q TEFORV9UWVBFX09WRVJMQVk6Ci0JCS8qIFRPRE86IGFkZCB2aWRlbyBsYXllciAodmwpIHN1cHBv cnQgKi8KKwkJaGVscGVyID0gJnp4X3ZsX3BsYW5lX2hlbHBlcl9mdW5jczsKKwkJZm9ybWF0cyA9 IHZsX2Zvcm1hdHM7CisJCWZvcm1hdF9jb3VudCA9IEFSUkFZX1NJWkUodmxfZm9ybWF0cyk7CiAJ CWJyZWFrOwogCWRlZmF1bHQ6CiAJCXJldHVybiBFUlJfUFRSKC1FTk9ERVYpOwpkaWZmIC0tZ2l0 IGEvZHJpdmVycy9ncHUvZHJtL3p0ZS96eF9wbGFuZV9yZWdzLmggYi9kcml2ZXJzL2dwdS9kcm0v enRlL3p4X3BsYW5lX3JlZ3MuaAppbmRleCAzZGRlNjcxNmE1NTguLjY1ZjI3MWFlYWJlZCAxMDA2 NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3p0ZS96eF9wbGFuZV9yZWdzLmgKKysrIGIvZHJpdmVy cy9ncHUvZHJtL3p0ZS96eF9wbGFuZV9yZWdzLmgKQEAgLTQ2LDYgKzQ2LDM3IEBACiAjZGVmaW5l IEdMX1BPU19YKHgpCSgoKHgpIDw8IEdMX1BPU19YX1NISUZUKSAmIEdMX1BPU19YX01BU0spCiAj ZGVmaW5lIEdMX1BPU19ZKHgpCSgoKHgpIDw8IEdMX1BPU19ZX1NISUZUKSAmIEdMX1BPU19ZX01B U0spCiAKKy8qIFZMIHJlZ2lzdGVycyAqLworI2RlZmluZSBWTF9DVFJMMAkJCTB4MDAKKyNkZWZp bmUgVkxfVVBEQVRFCQkJQklUKDMpCisjZGVmaW5lIFZMX0NUUkwxCQkJMHgwNAorI2RlZmluZSBW TF9ZVVY0MjBfUExBTkFSCQlCSVQoNSkKKyNkZWZpbmUgVkxfWVVWNDIyX1NISUZUCQkJMworI2Rl ZmluZSBWTF9ZVVY0MjJfWVVZVgkJCSgwIDw8IFZMX1lVVjQyMl9TSElGVCkKKyNkZWZpbmUgVkxf WVVWNDIyX1lWWVUJCQkoMSA8PCBWTF9ZVVY0MjJfU0hJRlQpCisjZGVmaW5lIFZMX1lVVjQyMl9V WVZZCQkJKDIgPDwgVkxfWVVWNDIyX1NISUZUKQorI2RlZmluZSBWTF9ZVVY0MjJfVllVWQkJCSgz IDw8IFZMX1lVVjQyMl9TSElGVCkKKyNkZWZpbmUgVkxfRk1UX1lVVjQyMAkJCTAKKyNkZWZpbmUg VkxfRk1UX1lVVjQyMgkJCTEKKyNkZWZpbmUgVkxfRk1UX1lVVjQyMF9QMDEwCQkyCisjZGVmaW5l IFZMX0ZNVF9ZVVY0MjBfSEFOVFJPCQkzCisjZGVmaW5lIFZMX0ZNVF9ZVVY0NDRfOEJJVAkJNAor I2RlZmluZSBWTF9GTVRfWVVWNDQ0XzEwQklUCQk1CisjZGVmaW5lIFZMX0NUUkwyCQkJMHgwOAor I2RlZmluZSBWTF9TQ0FMRVJfQllQQVNTX01PREUJCUJJVCgwKQorI2RlZmluZSBWTF9TVFJJREUJ CQkweDBjCisjZGVmaW5lIExVTUFfU1RSSURFX1NISUZUCQkxNgorI2RlZmluZSBMVU1BX1NUUklE RV9NQVNLCQkoMHhmZmZmIDw8IExVTUFfU1RSSURFX1NISUZUKQorI2RlZmluZSBDSFJPTUFfU1RS SURFX1NISUZUCQkwCisjZGVmaW5lIENIUk9NQV9TVFJJREVfTUFTSwkJKDB4ZmZmZiA8PCBDSFJP TUFfU1RSSURFX1NISUZUKQorI2RlZmluZSBWTF9TUkNfU0laRQkJCTB4MTAKKyNkZWZpbmUgVkxf WQkJCQkweDE0CisjZGVmaW5lIFZMX1BPU19TVEFSVAkJCTB4MzAKKyNkZWZpbmUgVkxfUE9TX0VO RAkJCTB4MzQKKworI2RlZmluZSBMVU1BX1NUUklERSh4KQkgKCgoeCkgPDwgTFVNQV9TVFJJREVf U0hJRlQpICYgTFVNQV9TVFJJREVfTUFTSykKKyNkZWZpbmUgQ0hST01BX1NUUklERSh4KSAoKCh4 KSA8PCBDSFJPTUFfU1RSSURFX1NISUZUKSAmIENIUk9NQV9TVFJJREVfTUFTSykKKwogLyogQ1ND IHJlZ2lzdGVycyAqLwogI2RlZmluZSBDU0NfQ1RSTDAJCQkweDMwCiAjZGVmaW5lIENTQ19DT1Zf TU9ERV9TSElGVAkJMTYKQEAgLTY5LDYgKzEwMCwxOCBAQAogI2RlZmluZSBSU1pfREVTVF9DRkcJ CQkweDA0CiAjZGVmaW5lIFJTWl9FTkFCTEVfQ0ZHCQkJMHgxNAogCisjZGVmaW5lIFJTWl9WTF9M VU1BX0hPUgkJCTB4MDgKKyNkZWZpbmUgUlNaX1ZMX0xVTUFfVkVSCQkJMHgwYworI2RlZmluZSBS U1pfVkxfQ0hST01BX0hPUgkJMHgxMAorI2RlZmluZSBSU1pfVkxfQ0hST01BX1ZFUgkJMHgxNAor I2RlZmluZSBSU1pfVkxfQ1RSTF9DRkcJCQkweDE4CisjZGVmaW5lIFJTWl9WTF9GTVRfU0hJRlQJ CTMKKyNkZWZpbmUgUlNaX1ZMX0ZNVF9NQVNLCQkJKDB4MyA8PCBSU1pfVkxfRk1UX1NISUZUKQor I2RlZmluZSBSU1pfVkxfRk1UX1lDQkNSNDIwCQkoMHgwIDw8IFJTWl9WTF9GTVRfU0hJRlQpCisj ZGVmaW5lIFJTWl9WTF9GTVRfWUNCQ1I0MjIJCSgweDEgPDwgUlNaX1ZMX0ZNVF9TSElGVCkKKyNk ZWZpbmUgUlNaX1ZMX0ZNVF9ZQ0JDUjQ0NAkJKDB4MiA8PCBSU1pfVkxfRk1UX1NISUZUKQorI2Rl ZmluZSBSU1pfVkxfRU5BQkxFX0NGRwkJMHgxYworCiAjZGVmaW5lIFJTWl9WRVJfU0hJRlQJCQkx NgogI2RlZmluZSBSU1pfVkVSX01BU0sJCQkoMHhmZmZmIDw8IFJTWl9WRVJfU0hJRlQpCiAjZGVm aW5lIFJTWl9IT1JfU0hJRlQJCQkwCkBAIC03Nyw2ICsxMjAsMTQgQEAKICNkZWZpbmUgUlNaX1ZF Uih4KQkoKCh4KSA8PCBSU1pfVkVSX1NISUZUKSAmIFJTWl9WRVJfTUFTSykKICNkZWZpbmUgUlNa X0hPUih4KQkoKCh4KSA8PCBSU1pfSE9SX1NISUZUKSAmIFJTWl9IT1JfTUFTSykKIAorI2RlZmlu ZSBSU1pfREFUQV9TVEVQX1NISUZUCQkxNgorI2RlZmluZSBSU1pfREFUQV9TVEVQX01BU0sJCSgw eGZmZmYgPDwgUlNaX0RBVEFfU1RFUF9TSElGVCkKKyNkZWZpbmUgUlNaX1BBUkFfU1RFUF9TSElG VAkJMAorI2RlZmluZSBSU1pfUEFSQV9TVEVQX01BU0sJCSgweGZmZmYgPDwgUlNaX1BBUkFfU1RF UF9TSElGVCkKKworI2RlZmluZSBSU1pfREFUQV9TVEVQKHgpICgoKHgpIDw8IFJTWl9EQVRBX1NU RVBfU0hJRlQpICYgUlNaX0RBVEFfU1RFUF9NQVNLKQorI2RlZmluZSBSU1pfUEFSQV9TVEVQKHgp ICgoKHgpIDw8IFJTWl9QQVJBX1NURVBfU0hJRlQpICYgUlNaX1BBUkFfU1RFUF9NQVNLKQorCiAv KiBIQlNDIHJlZ2lzdGVycyAqLwogI2RlZmluZSBIQlNDX1NBVFVSQVRJT04JCQkweDAwCiAjZGVm aW5lIEhCU0NfSFVFCQkJMHgwNApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3p0ZS96eF92 b3UuYyBiL2RyaXZlcnMvZ3B1L2RybS96dGUvenhfdm91LmMKaW5kZXggNzNmZTE1YzE3YzMyLi44 Y2E5YzRiZGVlYWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS96dGUvenhfdm91LmMKKysr IGIvZHJpdmVycy9ncHUvZHJtL3p0ZS96eF92b3UuYwpAQCAtOTMsMTAgKzkzLDM4IEBAIHN0cnVj dCB6eF9jcnRjIHsKIAljb25zdCBzdHJ1Y3QgenhfY3J0Y19iaXRzICpiaXRzOwogCWVudW0gdm91 X2Nobl90eXBlIGNobl90eXBlOwogCXN0cnVjdCBjbGsgKnBpeGNsazsKKwl1MzIgb3ZlcmxheV9i aXRtYXA7CiB9OwogCiAjZGVmaW5lIHRvX3p4X2NydGMoeCkgY29udGFpbmVyX29mKHgsIHN0cnVj dCB6eF9jcnRjLCBjcnRjKQogCitzdHJ1Y3QgenhfdmxfYml0cyB7CisJdTMyIGVuYWJsZTsKKwl1 MzIgY2huc2VsOworCXUzMiBjbGtzZWw7Cit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IHp4X3Zs X2JpdHMgenhfdmxfYml0c1tWTF9OVU1dID0geworCXsKKwkJLmVuYWJsZSA9IE9TRF9DVFJMMF9W TDBfRU4sCisJCS5jaG5zZWwgPSBPU0RfQ1RSTDBfVkwwX1NFTCwKKwkJLmNsa3NlbCA9IFZPVV9D TEtfVkwwX1NFTCwKKwl9LCB7CisJCS5lbmFibGUgPSBPU0RfQ1RSTDBfVkwxX0VOLAorCQkuY2hu c2VsID0gT1NEX0NUUkwwX1ZMMV9TRUwsCisJCS5jbGtzZWwgPSBWT1VfQ0xLX1ZMMV9TRUwsCisJ fSwgeworCQkuZW5hYmxlID0gT1NEX0NUUkwwX1ZMMl9FTiwKKwkJLmNobnNlbCA9IE9TRF9DVFJM MF9WTDJfU0VMLAorCQkuY2xrc2VsID0gVk9VX0NMS19WTDJfU0VMLAorCX0sCit9OworCitzdHJ1 Y3Qgenhfb3ZlcmxheSB7CisJc3RydWN0IGRybV9wbGFuZSAqcGxhbmU7CisJY29uc3Qgc3RydWN0 IHp4X3ZsX2JpdHMgKmJpdHM7Cit9OworCiBzdHJ1Y3Qgenhfdm91X2h3IHsKIAlzdHJ1Y3QgZGV2 aWNlICpkZXY7CiAJdm9pZCBfX2lvbWVtICpvc2Q7CkBAIC0xMTAsNiArMTM4LDcgQEAgc3RydWN0 IHp4X3ZvdV9odyB7CiAJc3RydWN0IGNsayAqYXV4X2NsazsKIAlzdHJ1Y3QgenhfY3J0YyAqbWFp bl9jcnRjOwogCXN0cnVjdCB6eF9jcnRjICphdXhfY3J0YzsKKwlzdHJ1Y3Qgenhfb3ZlcmxheSBv dmVybGF5c1tWTF9OVU1dOwogfTsKIAogc3RhdGljIGlubGluZSBzdHJ1Y3Qgenhfdm91X2h3ICpj cnRjX3RvX3ZvdShzdHJ1Y3QgZHJtX2NydGMgKmNydGMpCkBAIC00MDQsNiArNDMzLDExMiBAQCB2 b2lkIHp4X3ZvdV9kaXNhYmxlX3ZibGFuayhzdHJ1Y3QgZHJtX2RldmljZSAqZHJtLCB1bnNpZ25l ZCBpbnQgcGlwZSkKIAkJICAgICAgIHpjcnRjLT5iaXRzLT5pbnRfZnJhbWVfbWFzaywgMCk7CiB9 CiAKK3N0YXRpYyBpbnQgenhfb3ZlcmxheV9maW5kX3ZsX2lkeChzdHJ1Y3QgZHJtX3BsYW5lICpw bGFuZSwKKwkJCQkgIHN0cnVjdCB6eF92b3VfaHcgKnZvdSkKK3sKKwlpbnQgaTsKKworCWZvciAo aSA9IDA7IGkgPCBWTF9OVU07IGkrKykgeworCQlpZiAodm91LT5vdmVybGF5c1tpXS5wbGFuZSA9 PSBwbGFuZSkKKwkJCWJyZWFrOworCX0KKworCWlmIChpID09IFZMX05VTSkgeworCQlEUk1fREVW X0VSUk9SKHZvdS0+ZGV2LCAiZmFpbGVkIHRvIGZpbmQgVkxcbiIpOworCQlyZXR1cm4gLUVJTlZB TDsKKwl9CisKKwlyZXR1cm4gaTsKK30KKwordm9pZCB6eF9vdmVybGF5X2VuYWJsZShzdHJ1Y3Qg ZHJtX3BsYW5lICpwbGFuZSkKK3sKKwlzdHJ1Y3QgenhfY3J0YyAqemNydGMgPSB0b196eF9jcnRj KHBsYW5lLT5zdGF0ZS0+Y3J0Yyk7CisJc3RydWN0IHp4X3ZvdV9odyAqdm91ID0gemNydGMtPnZv dTsKKwljb25zdCBzdHJ1Y3QgenhfdmxfYml0cyAqYml0czsKKwlpbnQgaWR4OworCisJaWR4ID0g enhfb3ZlcmxheV9maW5kX3ZsX2lkeChwbGFuZSwgdm91KTsKKwlpZiAoaWR4IDwgMCkKKwkJcmV0 dXJuOworCisJYml0cyA9IHZvdS0+b3ZlcmxheXNbaWR4XS5iaXRzOworCXpjcnRjLT5vdmVybGF5 X2JpdG1hcCB8PSAxIDw8IGlkeDsKKworCWlmICh6Y3J0Yy0+Y2huX3R5cGUgPT0gVk9VX0NITl9N QUlOKSB7CisJCXp4X3dyaXRlbF9tYXNrKHZvdS0+b3NkICsgT1NEX0NUUkwwLCBiaXRzLT5jaG5z ZWwsIDApOworCQl6eF93cml0ZWxfbWFzayh2b3UtPnZvdWN0bCArIFZPVV9DTEtfU0VMLCBiaXRz LT5jbGtzZWwsIDApOworCX0gZWxzZSB7CisJCXp4X3dyaXRlbF9tYXNrKHZvdS0+b3NkICsgT1NE X0NUUkwwLCBiaXRzLT5jaG5zZWwsCisJCQkgICAgICAgYml0cy0+Y2huc2VsKTsKKwkJenhfd3Jp dGVsX21hc2sodm91LT52b3VjdGwgKyBWT1VfQ0xLX1NFTCwgYml0cy0+Y2xrc2VsLAorCQkJICAg ICAgIGJpdHMtPmNsa3NlbCk7CisJfQorCisJenhfd3JpdGVsX21hc2sodm91LT5vc2QgKyBPU0Rf Q1RSTDAsIGJpdHMtPmVuYWJsZSwgYml0cy0+ZW5hYmxlKTsKK30KKwordm9pZCB6eF9vdmVybGF5 X2Rpc2FibGUoc3RydWN0IGRybV9wbGFuZSAqcGxhbmUpCit7CisJc3RydWN0IHp4X2NydGMgKnpj cnRjID0gdG9fenhfY3J0YyhwbGFuZS0+Y3J0Yyk7CisJc3RydWN0IHp4X3ZvdV9odyAqdm91ID0g emNydGMtPnZvdTsKKwljb25zdCBzdHJ1Y3QgenhfdmxfYml0cyAqYml0czsKKwlpbnQgaWR4Owor CisJaWR4ID0genhfb3ZlcmxheV9maW5kX3ZsX2lkeChwbGFuZSwgdm91KTsKKwlpZiAoaWR4IDwg MCkKKwkJcmV0dXJuOworCisJYml0cyA9IHZvdS0+b3ZlcmxheXNbaWR4XS5iaXRzOworCXpjcnRj LT5vdmVybGF5X2JpdG1hcCAmPSB+KDEgPDwgaWR4KTsKKworCXp4X3dyaXRlbF9tYXNrKHZvdS0+ b3NkICsgT1NEX0NUUkwwLCBiaXRzLT5lbmFibGUsIDApOworfQorCitzdGF0aWMgdm9pZCB6eF9v dmVybGF5X2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRybSwgc3RydWN0IHp4X3ZvdV9odyAqdm91 KQoreworCXN0cnVjdCBkZXZpY2UgKmRldiA9IHZvdS0+ZGV2OworCXN0cnVjdCBkcm1fcGxhbmUg KnBsYW5lOworCXN0cnVjdCB6eF9sYXllcl9kYXRhIGRhdGE7CisJaW50IGk7CisKKwkvKgorCSAq IFZMMCBoYXMgc29tZSBxdWlya3Mgb24gc2NhbGluZyBzdXBwb3J0IHdoaWNoIG5lZWQgc3BlY2lh bCBoYW5kbGluZy4KKwkgKiBMZXQncyBsZWF2ZSBpdCBvdXQgZm9yIG5vdy4KKwkgKi8KKwlmb3Ig KGkgPSAxOyBpIDwgVkxfTlVNOyBpKyspIHsKKwkJZGF0YS5sYXllciA9IHZvdS0+b3NkICsgT1NE X1ZMX09GRlNFVChpKTsKKwkJZGF0YS5oYnNjID0gdm91LT5vc2QgKyBIQlNDX1ZMX09GRlNFVChp KTsKKwkJZGF0YS5yc3ogPSB2b3UtPm90ZnBwdSArIFJTWl9WTF9PRkZTRVQoaSk7CisKKwkJcGxh bmUgPSB6eF9wbGFuZV9pbml0KGRybSwgZGV2LCAmZGF0YSwgRFJNX1BMQU5FX1RZUEVfT1ZFUkxB WSk7CisJCWlmIChJU19FUlIocGxhbmUpKSB7CisJCQlEUk1fREVWX0VSUk9SKGRldiwgImZhaWxl ZCB0byBpbml0IG92ZXJsYXkgJWRcbiIsIGkpOworCQkJY29udGludWU7CisJCX0KKworCQl2b3Ut Pm92ZXJsYXlzW2ldLnBsYW5lID0gcGxhbmU7CisJCXZvdS0+b3ZlcmxheXNbaV0uYml0cyA9ICZ6 eF92bF9iaXRzW2ldOworCX0KK30KKworc3RhdGljIGlubGluZSB2b2lkIHp4X29zZF9pbnRfdXBk YXRlKHN0cnVjdCB6eF9jcnRjICp6Y3J0YykKK3sKKwl1MzIgYml0bWFwID0gemNydGMtPm92ZXJs YXlfYml0bWFwOworCWludCBpOworCisJdm91X2Nobl9zZXRfdXBkYXRlKHpjcnRjKTsKKwl6eF9w bGFuZV9zZXRfdXBkYXRlKHpjcnRjLT5wcmltYXJ5KTsKKworCWlmIChiaXRtYXApIHsKKwkJZm9y IChpID0gMDsgaSA8IFZMX05VTTsgaSsrKSAgeworCQkJaWYgKChiaXRtYXAgJiAoMSA8PCBpKSkg PT0gMCkKKwkJCQljb250aW51ZTsKKwkJCXp4X3BsYW5lX3NldF91cGRhdGUoemNydGMtPnZvdS0+ b3ZlcmxheXNbaV0ucGxhbmUpOworCQl9CisJfQorfQorCiBzdGF0aWMgaXJxcmV0dXJuX3Qgdm91 X2lycV9oYW5kbGVyKGludCBpcnEsIHZvaWQgKmRldl9pZCkKIHsKIAlzdHJ1Y3Qgenhfdm91X2h3 ICp2b3UgPSBkZXZfaWQ7CkBAIC00MjMsMTUgKzU1OCwxMSBAQCBzdGF0aWMgaXJxcmV0dXJuX3Qg dm91X2lycV9oYW5kbGVyKGludCBpcnEsIHZvaWQgKmRldl9pZCkKIAlzdGF0ZSA9IHp4X3JlYWRs KHZvdS0+b3NkICsgT1NEX0lOVF9TVEEpOwogCXp4X3dyaXRlbCh2b3UtPm9zZCArIE9TRF9JTlRf Q0xSU1RBLCBzdGF0ZSk7CiAKLQlpZiAoc3RhdGUgJiBPU0RfSU5UX01BSU5fVVBUKSB7Ci0JCXZv dV9jaG5fc2V0X3VwZGF0ZSh2b3UtPm1haW5fY3J0Yyk7Ci0JCXp4X3BsYW5lX3NldF91cGRhdGUo dm91LT5tYWluX2NydGMtPnByaW1hcnkpOwotCX0KKwlpZiAoc3RhdGUgJiBPU0RfSU5UX01BSU5f VVBUKQorCQl6eF9vc2RfaW50X3VwZGF0ZSh2b3UtPm1haW5fY3J0Yyk7CiAKLQlpZiAoc3RhdGUg JiBPU0RfSU5UX0FVWF9VUFQpIHsKLQkJdm91X2Nobl9zZXRfdXBkYXRlKHZvdS0+YXV4X2NydGMp OwotCQl6eF9wbGFuZV9zZXRfdXBkYXRlKHZvdS0+YXV4X2NydGMtPnByaW1hcnkpOwotCX0KKwlp ZiAoc3RhdGUgJiBPU0RfSU5UX0FVWF9VUFQpCisJCXp4X29zZF9pbnRfdXBkYXRlKHZvdS0+YXV4 X2NydGMpOwogCiAJaWYgKHN0YXRlICYgT1NEX0lOVF9FUlJPUikKIAkJRFJNX0RFVl9FUlJPUih2 b3UtPmRldiwgIk9TRCBFUlJPUjogMHglMDh4IVxuIiwgc3RhdGUpOwpAQCAtNjExLDYgKzc0Miw4 IEBAIHN0YXRpYyBpbnQgenhfY3J0Y19iaW5kKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRl dmljZSAqbWFzdGVyLCB2b2lkICpkYXRhKQogCQlnb3RvIGRpc2FibGVfcHB1X2NsazsKIAl9CiAK Kwl6eF9vdmVybGF5X2luaXQoZHJtLCB2b3UpOworCiAJcmV0dXJuIDA7CiAKIGRpc2FibGVfcHB1 X2NsazoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS96dGUvenhfdm91LmggYi9kcml2ZXJz L2dwdS9kcm0venRlL3p4X3ZvdS5oCmluZGV4IDM0OWUwNmNkODZmNC4uMTU1OWMxZjc5ZGI3IDEw MDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0venRlL3p4X3ZvdS5oCisrKyBiL2RyaXZlcnMvZ3B1 L2RybS96dGUvenhfdm91LmgKQEAgLTQzLDQgKzQzLDcgQEAgc3RydWN0IHZvdV9pbmYgewogaW50 IHp4X3ZvdV9lbmFibGVfdmJsYW5rKHN0cnVjdCBkcm1fZGV2aWNlICpkcm0sIHVuc2lnbmVkIGlu dCBwaXBlKTsKIHZvaWQgenhfdm91X2Rpc2FibGVfdmJsYW5rKHN0cnVjdCBkcm1fZGV2aWNlICpk cm0sIHVuc2lnbmVkIGludCBwaXBlKTsKIAordm9pZCB6eF9vdmVybGF5X2VuYWJsZShzdHJ1Y3Qg ZHJtX3BsYW5lICpwbGFuZSk7Cit2b2lkIHp4X292ZXJsYXlfZGlzYWJsZShzdHJ1Y3QgZHJtX3Bs YW5lICpwbGFuZSk7CisKICNlbmRpZiAvKiBfX1pYX1ZPVV9IX18gKi8KZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS96dGUvenhfdm91X3JlZ3MuaCBiL2RyaXZlcnMvZ3B1L2RybS96dGUvenhf dm91X3JlZ3MuaAppbmRleCBmNDRlN2E0YWU0NDEuLjE5M2MxY2UwMWZlNyAxMDA2NDQKLS0tIGEv ZHJpdmVycy9ncHUvZHJtL3p0ZS96eF92b3VfcmVncy5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS96 dGUvenhfdm91X3JlZ3MuaApAQCAtMjIsNiArMjIsMTUgQEAKICNkZWZpbmUgQVVYX0hCU0NfT0ZG U0VUCQkJMHg4NjAKICNkZWZpbmUgQVVYX1JTWl9PRkZTRVQJCQkweDgwMAogCisjZGVmaW5lIE9T RF9WTDBfT0ZGU0VUCQkJMHgwNDAKKyNkZWZpbmUgT1NEX1ZMX09GRlNFVChpKQkJKE9TRF9WTDBf T0ZGU0VUICsgMHgwNTAgKiAoaSkpCisKKyNkZWZpbmUgSEJTQ19WTDBfT0ZGU0VUCQkJMHg3NjAK KyNkZWZpbmUgSEJTQ19WTF9PRkZTRVQoaSkJCShIQlNDX1ZMMF9PRkZTRVQgKyAweDA0MCAqIChp KSkKKworI2RlZmluZSBSU1pfVkwxX1UwCQkJMHhhMDAKKyNkZWZpbmUgUlNaX1ZMX09GRlNFVChp KQkJKFJTWl9WTDFfVTAgKyAweDIwMCAqIChpKSkKKwogLyogT1NEIChHUENfR0xPQkFMKSByZWdp c3RlcnMgKi8KICNkZWZpbmUgT1NEX0lOVF9TVEEJCQkweDA0CiAjZGVmaW5lIE9TRF9JTlRfQ0xS U1RBCQkJMHgwOApAQCAtNDIsNiArNTEsMTIgQEAKICkKICNkZWZpbmUgT1NEX0lOVF9FTkFCTEUg KE9TRF9JTlRfRVJST1IgfCBPU0RfSU5UX0FVWF9VUFQgfCBPU0RfSU5UX01BSU5fVVBUKQogI2Rl ZmluZSBPU0RfQ1RSTDAJCQkweDEwCisjZGVmaW5lIE9TRF9DVFJMMF9WTDBfRU4JCUJJVCgxMykK KyNkZWZpbmUgT1NEX0NUUkwwX1ZMMF9TRUwJCUJJVCgxMikKKyNkZWZpbmUgT1NEX0NUUkwwX1ZM MV9FTgkJQklUKDExKQorI2RlZmluZSBPU0RfQ1RSTDBfVkwxX1NFTAkJQklUKDEwKQorI2RlZmlu ZSBPU0RfQ1RSTDBfVkwyX0VOCQlCSVQoOSkKKyNkZWZpbmUgT1NEX0NUUkwwX1ZMMl9TRUwJCUJJ VCg4KQogI2RlZmluZSBPU0RfQ1RSTDBfR0wwX0VOCQlCSVQoNykKICNkZWZpbmUgT1NEX0NUUkww X0dMMF9TRUwJCUJJVCg2KQogI2RlZmluZSBPU0RfQ1RSTDBfR0wxX0VOCQlCSVQoNSkKQEAgLTE0 Niw2ICsxNjEsOSBAQAogI2RlZmluZSBWT1VfSU5GX0RBVEFfU0VMCQkweDA4CiAjZGVmaW5lIFZP VV9TT0ZUX1JTVAkJCTB4MTQKICNkZWZpbmUgVk9VX0NMS19TRUwJCQkweDE4CisjZGVmaW5lIFZP VV9DTEtfVkwyX1NFTAkJCUJJVCg4KQorI2RlZmluZSBWT1VfQ0xLX1ZMMV9TRUwJCQlCSVQoNykK KyNkZWZpbmUgVk9VX0NMS19WTDBfU0VMCQkJQklUKDYpCiAjZGVmaW5lIFZPVV9DTEtfR0wxX1NF TAkJCUJJVCg1KQogI2RlZmluZSBWT1VfQ0xLX0dMMF9TRUwJCQlCSVQoNCkKICNkZWZpbmUgVk9V X0NMS19SRVFFTgkJCTB4MjAKLS0gCjEuOS4xCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0 cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9s aXN0aW5mby9kcmktZGV2ZWwK