From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id CCAB5C4332F for ; Tue, 18 Oct 2022 15:20:33 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229959AbiJRPUb (ORCPT ); Tue, 18 Oct 2022 11:20:31 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:51692 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229574AbiJRPU1 (ORCPT ); Tue, 18 Oct 2022 11:20:27 -0400 Received: from madras.collabora.co.uk (madras.collabora.co.uk [IPv6:2a00:1098:0:82:1000:25:2eeb:e5ab]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 0F6959412C; Tue, 18 Oct 2022 08:20:26 -0700 (PDT) Received: from nicolas-tpx395.localdomain (192-222-136-102.qc.cable.ebox.net [192.222.136.102]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) (Authenticated sender: nicolas) by madras.collabora.co.uk (Postfix) with ESMTPSA id A8681660035C; Tue, 18 Oct 2022 16:20:22 +0100 (BST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=collabora.com; s=mail; t=1666106424; bh=hcGU7f2VWGhlcxE4rVQ+mVCpg2sdCRIPSaRmUZxYE0A=; h=Subject:From:To:Date:In-Reply-To:References:From; b=KYd0rpCB1h0ybwIZP/sZD7SPX5E9qw5ofpBKQIn00e+WHIPBQumpLISuQNVhEkHmP LU8RoMV3iAoYwTMuNPcgPsfTd0IJz9gdeQMIusMzJuFUtL/4jd1OEPDS0iw0hjZGPk E7Zl/eCC3kxAANA6ZfuVwC7R4gAMf7nfzoKamKWsbJCYhzLwqs9mg+P7+X20cAqRw/ z2GyJAlgew02RseuUuFa5mqipVU6pGLVJGKPwnpahh+b2NYvsUrJIag/XrLT8/WE4h aQRj9oxYzCy52mpE+ZueAGx3HGIO2jfq1nXIpyu0eIimIzITtmwwvuswm4Sl9MlSHN izmAkcWfvdzhg== Message-ID: Subject: Re: [PATCH v9 3/4] media: aspeed: Support aspeed mode to reduce compressed data From: Nicolas Dufresne To: Jammy Huang , eajames@linux.ibm.com, mchehab@kernel.org, joel@jms.id.au, andrew@aj.id.au, linux-media@vger.kernel.org, openbmc@lists.ozlabs.org, linux-arm-kernel@lists.infradead.org, linux-aspeed@lists.ozlabs.org, linux-kernel@vger.kernel.org, hverkuil-cisco@xs4all.nl, ezequiel@vanguardiasur.com.ar, stanimir.varbanov@linaro.org, laurent.pinchart@ideasonboard.com, sakari.ailus@linux.intel.com, ribalda@chromium.org Date: Tue, 18 Oct 2022 11:20:13 -0400 In-Reply-To: <20220921025112.13150-4-jammy_huang@aspeedtech.com> References: <20220921025112.13150-1-jammy_huang@aspeedtech.com> <20220921025112.13150-4-jammy_huang@aspeedtech.com> Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable User-Agent: Evolution 3.44.4 (3.44.4-2.fc36) MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hi, Le mercredi 21 septembre 2022 =C3=A0 10:51 +0800, Jammy Huang a =C3=A9crit= =C2=A0: > aspeed supports differential jpeg format which only compress the parts > which are changed. In this way, it reduces both the amount of data to be > transferred by network and those to be decoded on the client side. >=20 > 2 new ctrls are added: > * Aspeed HQ Mode: to control aspeed's high quality(2-pass) compression mo= de > This only works with yuv444 subsampling. > * Aspeed HQ Quality: to control the quality of aspeed's HQ mode > only useful if Aspeed HQ mode is enabled >=20 > Aspeed JPEG Format requires an additional buffer, called bcd, to store > the information about which macro block in the new frame is different > from the previous one. >=20 > To have bcd correctly working, we need to swap the buffers for src0/1 to > make src1 refer to previous frame and src0 to the coming new frame. >=20 > Signed-off-by: Jammy Huang > --- > drivers/media/platform/aspeed/aspeed-video.c | 281 +++++++++++++++---- > include/uapi/linux/aspeed-video.h | 15 + > 2 files changed, 245 insertions(+), 51 deletions(-) > create mode 100644 include/uapi/linux/aspeed-video.h >=20 > diff --git a/drivers/media/platform/aspeed/aspeed-video.c b/drivers/media= /platform/aspeed/aspeed-video.c > index 20f795ccc11b..739288026418 100644 > --- a/drivers/media/platform/aspeed/aspeed-video.c > +++ b/drivers/media/platform/aspeed/aspeed-video.c > @@ -33,6 +33,7 @@ > #include > #include > #include > +#include > =20 > #define ASPEED_VIDEO_V4L2_MIN_BUF_REQ 3 > =20 > @@ -59,6 +60,7 @@ > =20 > #define VE_MAX_SRC_BUFFER_SIZE 0x8ca000 /* 1920 * 1200, 32bpp */ > #define VE_JPEG_HEADER_SIZE 0x006000 /* 512 * 12 * 4 */ > +#define VE_BCD_BUFF_SIZE 0x9000 /* (1920/8) * (1200/8) */ > =20 > #define VE_PROTECTION_KEY 0x000 > #define VE_PROTECTION_KEY_UNLOCK 0x1a038aa8 > @@ -107,6 +109,13 @@ > #define VE_SCALING_FILTER2 0x020 > #define VE_SCALING_FILTER3 0x024 > =20 > +#define VE_BCD_CTRL 0x02C > +#define VE_BCD_CTRL_EN_BCD BIT(0) > +#define VE_BCD_CTRL_EN_ABCD BIT(1) > +#define VE_BCD_CTRL_EN_CB BIT(2) > +#define VE_BCD_CTRL_THR GENMASK(23, 16) > +#define VE_BCD_CTRL_ABCD_THR GENMASK(31, 24) > + > #define VE_CAP_WINDOW 0x030 > #define VE_COMP_WINDOW 0x034 > #define VE_COMP_PROC_OFFSET 0x038 > @@ -115,6 +124,7 @@ > #define VE_SRC0_ADDR 0x044 > #define VE_SRC_SCANLINE_OFFSET 0x048 > #define VE_SRC1_ADDR 0x04c > +#define VE_BCD_ADDR 0x050 > #define VE_COMP_ADDR 0x054 > =20 > #define VE_STREAM_BUF_SIZE 0x058 > @@ -135,6 +145,8 @@ > #define VE_COMP_CTRL_HQ_DCT_CHR GENMASK(26, 22) > #define VE_COMP_CTRL_HQ_DCT_LUM GENMASK(31, 27) > =20 > +#define VE_CB_ADDR 0x06C > + > #define AST2400_VE_COMP_SIZE_READ_BACK 0x078 > #define AST2600_VE_COMP_SIZE_READ_BACK 0x084 > =20 > @@ -211,6 +223,12 @@ enum { > VIDEO_CLOCKS_ON, > }; > =20 > +enum aspeed_video_format { > + VIDEO_FMT_STANDARD =3D 0, > + VIDEO_FMT_ASPEED, > + VIDEO_FMT_MAX =3D VIDEO_FMT_ASPEED > +}; > + > // for VE_CTRL_CAPTURE_FMT > enum aspeed_video_capture_format { > VIDEO_CAP_FMT_YUV_STUDIO_SWING =3D 0, > @@ -245,16 +263,20 @@ struct aspeed_video_perf { > /* > * struct aspeed_video - driver data > * > - * res_work: holds the delayed_work for res-detection if unloc= k > - * buffers: holds the list of buffer queued from user > + * res_work: holds the delayed_work for res-detection if unlock > + * buffers: holds the list of buffer queued from user > * flags: holds the state of video > * sequence: holds the last number of frame completed > * max_compressed_size: holds max compressed stream's size > * srcs: holds the buffer information for srcs > * jpeg: holds the buffer information for jpeg header > + * bcd: holds the buffer information for bcd work > * yuv420: a flag raised if JPEG subsampling is 420 > + * format: holds the video format > + * hq_mode: a flag raised if HQ is enabled. Only for VIDEO_FMT_ASPEED > * frame_rate: holds the frame_rate > * jpeg_quality: holds jpeq's quality (0~11) > + * jpeg_hq_quality: holds hq's quality (1~12) only if hq_mode enabled > * frame_bottom: end position of video data in vertical direction > * frame_left: start position of video data in horizontal direction > * frame_right: end position of video data in horizontal direction > @@ -290,10 +312,14 @@ struct aspeed_video { > unsigned int max_compressed_size; > struct aspeed_video_addr srcs[2]; > struct aspeed_video_addr jpeg; > + struct aspeed_video_addr bcd; > =20 > bool yuv420; > + enum aspeed_video_format format; > + bool hq_mode; > unsigned int frame_rate; > unsigned int jpeg_quality; > + unsigned int jpeg_hq_quality; > =20 > unsigned int frame_bottom; > unsigned int frame_left; > @@ -458,8 +484,20 @@ static const struct v4l2_dv_timings_cap aspeed_video= _timings_cap =3D { > }, > }; > =20 > +static const char * const compress_scheme_str[] =3D {"DCT Only", > + "DCT VQ mix 2-color", "DCT VQ mix 4-color"}; > +static const char * const format_str[] =3D {"Standard JPEG", > + "Aspeed JPEG"}; > + > static unsigned int debug; > =20 > +static bool aspeed_video_alloc_buf(struct aspeed_video *video, > + struct aspeed_video_addr *addr, > + unsigned int size); > + > +static void aspeed_video_free_buf(struct aspeed_video *video, > + struct aspeed_video_addr *addr); > + > static void aspeed_video_init_jpeg_table(u32 *table, bool yuv420) > { > int i; > @@ -547,6 +585,7 @@ static int aspeed_video_start_frame(struct aspeed_vid= eo *video) > unsigned long flags; > struct aspeed_video_buffer *buf; > u32 seq_ctrl =3D aspeed_video_read(video, VE_SEQ_CTRL); > + bool bcd_buf_need =3D (video->format !=3D VIDEO_FMT_STANDARD); > =20 > if (video->v4l2_input_status) { > v4l2_warn(&video->v4l2_dev, "No signal; don't start frame\n"); > @@ -559,6 +598,20 @@ static int aspeed_video_start_frame(struct aspeed_vi= deo *video) > return -EBUSY; > } > =20 > + if (bcd_buf_need && !video->bcd.size) { > + if (!aspeed_video_alloc_buf(video, &video->bcd, > + VE_BCD_BUFF_SIZE)) { > + dev_err(video->dev, "Failed to allocate BCD buffer\n"); > + dev_err(video->dev, "don't start frame\n"); > + return -ENOMEM; > + } > + aspeed_video_write(video, VE_BCD_ADDR, video->bcd.dma); > + v4l2_dbg(1, debug, &video->v4l2_dev, "bcd addr(%#x) size(%d)\n", > + video->bcd.dma, video->bcd.size); > + } else if (!bcd_buf_need && video->bcd.size) { > + aspeed_video_free_buf(video, &video->bcd); > + } > + > spin_lock_irqsave(&video->lock, flags); > buf =3D list_first_entry_or_null(&video->buffers, > struct aspeed_video_buffer, link); > @@ -657,6 +710,24 @@ static void aspeed_video_irq_res_change(struct aspee= d_video *video, ulong delay) > schedule_delayed_work(&video->res_work, delay); > } > =20 > +static void aspeed_video_swap_src_buf(struct aspeed_video *v) > +{ > + if (v->format =3D=3D VIDEO_FMT_STANDARD) > + return; > + > + /* Reset bcd buffer to have a full frame update every 8 frames. */ > + if (IS_ALIGNED(v->sequence, 8)) > + memset((u8 *)v->bcd.virt, 0x00, VE_BCD_BUFF_SIZE); > + > + if (v->sequence & 0x01) { > + aspeed_video_write(v, VE_SRC0_ADDR, v->srcs[1].dma); > + aspeed_video_write(v, VE_SRC1_ADDR, v->srcs[0].dma); > + } else { > + aspeed_video_write(v, VE_SRC0_ADDR, v->srcs[0].dma); > + aspeed_video_write(v, VE_SRC1_ADDR, v->srcs[1].dma); > + } > +} > + > static irqreturn_t aspeed_video_irq(int irq, void *arg) > { > struct aspeed_video *video =3D arg; > @@ -705,6 +776,7 @@ static irqreturn_t aspeed_video_irq(int irq, void *ar= g) > =20 > if (sts & VE_INTERRUPT_COMP_COMPLETE) { > struct aspeed_video_buffer *buf; > + bool empty =3D true; > u32 frame_size =3D aspeed_video_read(video, > video->comp_size_read); > =20 > @@ -718,13 +790,23 @@ static irqreturn_t aspeed_video_irq(int irq, void *= arg) > if (buf) { > vb2_set_plane_payload(&buf->vb.vb2_buf, 0, frame_size); > =20 > - if (!list_is_last(&buf->link, &video->buffers)) { > + /* > + * aspeed_jpeg requires continuous update. > + * On the contrary, standard jpeg can keep last buffer > + * to always have the latest result. > + */ > + if (video->format =3D=3D VIDEO_FMT_STANDARD && > + list_is_last(&buf->link, &video->buffers)) { > + empty =3D false; > + v4l2_warn(&video->v4l2_dev, "skip to keep last frame updated\n"); > + } else { > buf->vb.vb2_buf.timestamp =3D ktime_get_ns(); > buf->vb.sequence =3D video->sequence++; > buf->vb.field =3D V4L2_FIELD_NONE; > vb2_buffer_done(&buf->vb.vb2_buf, > VB2_BUF_STATE_DONE); > list_del(&buf->link); > + empty =3D list_empty(&video->buffers); > } > } > spin_unlock(&video->lock); > @@ -738,7 +820,10 @@ static irqreturn_t aspeed_video_irq(int irq, void *a= rg) > aspeed_video_write(video, VE_INTERRUPT_STATUS, > VE_INTERRUPT_COMP_COMPLETE); > sts &=3D ~VE_INTERRUPT_COMP_COMPLETE; > - if (test_bit(VIDEO_STREAMING, &video->flags) && buf) > + > + aspeed_video_swap_src_buf(video); > + > + if (test_bit(VIDEO_STREAMING, &video->flags) && !empty) > aspeed_video_start_frame(video); > } > =20 > @@ -1085,10 +1170,14 @@ static void aspeed_video_set_resolution(struct as= peed_video *video) > FIELD_PREP(VE_TGS_FIRST, video->frame_top) | > FIELD_PREP(VE_TGS_LAST, > video->frame_bottom + 1)); > - aspeed_video_update(video, VE_CTRL, 0, VE_CTRL_INT_DE); > + aspeed_video_update(video, VE_CTRL, > + VE_CTRL_INT_DE | VE_CTRL_DIRECT_FETCH, > + VE_CTRL_INT_DE); > } else { > v4l2_dbg(1, debug, &video->v4l2_dev, "Capture: Direct Mode\n"); > - aspeed_video_update(video, VE_CTRL, 0, VE_CTRL_DIRECT_FETCH); > + aspeed_video_update(video, VE_CTRL, > + VE_CTRL_INT_DE | VE_CTRL_DIRECT_FETCH, > + VE_CTRL_DIRECT_FETCH); > } > =20 > size *=3D 4; > @@ -1121,21 +1210,66 @@ static void aspeed_video_set_resolution(struct as= peed_video *video) > aspeed_video_free_buf(video, &video->srcs[0]); > } > =20 > -static void aspeed_video_init_regs(struct aspeed_video *video) > +static void aspeed_video_update_regs(struct aspeed_video *video) > { > - u32 comp_ctrl =3D VE_COMP_CTRL_RSVD | > - FIELD_PREP(VE_COMP_CTRL_DCT_LUM, video->jpeg_quality) | > - FIELD_PREP(VE_COMP_CTRL_DCT_CHR, video->jpeg_quality | 0x10); > - u32 ctrl =3D VE_CTRL_AUTO_OR_CURSOR | > - FIELD_PREP(VE_CTRL_CAPTURE_FMT, VIDEO_CAP_FMT_YUV_FULL_SWING); > - u32 seq_ctrl =3D video->jpeg_mode; > + u8 jpeg_hq_quality =3D clamp((int)video->jpeg_hq_quality - 1, 0, > + ASPEED_VIDEO_JPEG_NUM_QUALITIES - 1); > + u32 comp_ctrl =3D FIELD_PREP(VE_COMP_CTRL_DCT_LUM, video->jpeg_quality)= | > + FIELD_PREP(VE_COMP_CTRL_DCT_CHR, video->jpeg_quality | 0x10) | > + FIELD_PREP(VE_COMP_CTRL_EN_HQ, video->hq_mode) | > + FIELD_PREP(VE_COMP_CTRL_HQ_DCT_LUM, jpeg_hq_quality) | > + FIELD_PREP(VE_COMP_CTRL_HQ_DCT_CHR, jpeg_hq_quality | 0x10); > + u32 ctrl =3D 0; > + u32 seq_ctrl =3D 0; > + > + v4l2_dbg(1, debug, &video->v4l2_dev, "framerate(%d)\n", > + video->frame_rate); > + v4l2_dbg(1, debug, &video->v4l2_dev, "jpeg format(%s) subsample(%s)\n", > + format_str[video->format], > + video->yuv420 ? "420" : "444"); > + v4l2_dbg(1, debug, &video->v4l2_dev, "compression quality(%d)\n", > + video->jpeg_quality); > + v4l2_dbg(1, debug, &video->v4l2_dev, "hq_mode(%s) hq_quality(%d)\n", > + video->hq_mode ? "on" : "off", video->jpeg_hq_quality); > + > + if (video->format =3D=3D VIDEO_FMT_ASPEED) > + aspeed_video_update(video, VE_BCD_CTRL, 0, VE_BCD_CTRL_EN_BCD); > + else > + aspeed_video_update(video, VE_BCD_CTRL, VE_BCD_CTRL_EN_BCD, 0); > =20 > if (video->frame_rate) > ctrl |=3D FIELD_PREP(VE_CTRL_FRC, video->frame_rate); > =20 > + if (video->format =3D=3D VIDEO_FMT_STANDARD) { > + comp_ctrl &=3D ~FIELD_PREP(VE_COMP_CTRL_EN_HQ, video->hq_mode); > + seq_ctrl |=3D video->jpeg_mode; > + } > + > if (video->yuv420) > seq_ctrl |=3D VE_SEQ_CTRL_YUV420; > =20 > + if (video->jpeg.virt) > + aspeed_video_update_jpeg_table(video->jpeg.virt, video->yuv420); > + > + > + /* Set control registers */ > + aspeed_video_update(video, VE_SEQ_CTRL, > + video->jpeg_mode | VE_SEQ_CTRL_YUV420, > + seq_ctrl); > + aspeed_video_update(video, VE_CTRL, VE_CTRL_FRC, ctrl); > + aspeed_video_update(video, VE_COMP_CTRL, > + VE_COMP_CTRL_DCT_LUM | VE_COMP_CTRL_DCT_CHR | > + VE_COMP_CTRL_EN_HQ | VE_COMP_CTRL_HQ_DCT_LUM | > + VE_COMP_CTRL_HQ_DCT_CHR | VE_COMP_CTRL_VQ_4COLOR | > + VE_COMP_CTRL_VQ_DCT_ONLY, > + comp_ctrl); > +} > + > +static void aspeed_video_init_regs(struct aspeed_video *video) > +{ > + u32 ctrl =3D VE_CTRL_AUTO_OR_CURSOR | > + FIELD_PREP(VE_CTRL_CAPTURE_FMT, VIDEO_CAP_FMT_YUV_FULL_SWING); > + > /* Unlock VE registers */ > aspeed_video_write(video, VE_PROTECTION_KEY, VE_PROTECTION_KEY_UNLOCK); > =20 > @@ -1150,9 +1284,8 @@ static void aspeed_video_init_regs(struct aspeed_vi= deo *video) > aspeed_video_write(video, VE_JPEG_ADDR, video->jpeg.dma); > =20 > /* Set control registers */ > - aspeed_video_write(video, VE_SEQ_CTRL, seq_ctrl); > aspeed_video_write(video, VE_CTRL, ctrl); > - aspeed_video_write(video, VE_COMP_CTRL, comp_ctrl); > + aspeed_video_write(video, VE_COMP_CTRL, VE_COMP_CTRL_RSVD); > =20 > /* Don't downscale */ > aspeed_video_write(video, VE_SCALING_FACTOR, 0x10001000); > @@ -1168,6 +1301,8 @@ static void aspeed_video_init_regs(struct aspeed_vi= deo *video) > FIELD_PREP(VE_MODE_DT_HOR_STABLE, 6) | > FIELD_PREP(VE_MODE_DT_VER_STABLE, 6) | > FIELD_PREP(VE_MODE_DT_EDG_THROD, 0x65)); > + > + aspeed_video_write(video, VE_BCD_CTRL, 0); > } > =20 > static void aspeed_video_start(struct aspeed_video *video) > @@ -1201,6 +1336,9 @@ static void aspeed_video_stop(struct aspeed_video *= video) > if (video->srcs[1].size) > aspeed_video_free_buf(video, &video->srcs[1]); > =20 > + if (video->bcd.size) > + aspeed_video_free_buf(video, &video->bcd); > + > video->v4l2_input_status =3D V4L2_IN_ST_NO_SIGNAL; > video->flags =3D 0; > } > @@ -1219,10 +1357,12 @@ static int aspeed_video_querycap(struct file *fil= e, void *fh, > static int aspeed_video_enum_format(struct file *file, void *fh, > struct v4l2_fmtdesc *f) > { > + struct aspeed_video *video =3D video_drvdata(file); > + > if (f->index) > return -EINVAL; > =20 > - f->pixelformat =3D V4L2_PIX_FMT_JPEG; > + f->pixelformat =3D video->pix_fmt.pixelformat; > =20 > return 0; > } > @@ -1237,6 +1377,29 @@ static int aspeed_video_get_format(struct file *fi= le, void *fh, > return 0; > } > =20 > +static int aspeed_video_set_format(struct file *file, void *fh, > + struct v4l2_format *f) > +{ > + struct aspeed_video *video =3D video_drvdata(file); > + > + if (vb2_is_busy(&video->queue)) > + return -EBUSY; > + > + switch (f->fmt.pix.pixelformat) { > + case V4L2_PIX_FMT_JPEG: > + video->format =3D VIDEO_FMT_STANDARD; > + break; > + case V4L2_PIX_FMT_AJPG: > + video->format =3D VIDEO_FMT_ASPEED; > + break; > + default: > + return -EINVAL; > + } > + video->pix_fmt.pixelformat =3D f->fmt.pix.pixelformat; > + > + return 0; > +} > + > static int aspeed_video_enum_input(struct file *file, void *fh, > struct v4l2_input *inp) > { > @@ -1454,7 +1617,7 @@ static const struct v4l2_ioctl_ops aspeed_video_ioc= tl_ops =3D { > =20 > .vidioc_enum_fmt_vid_cap =3D aspeed_video_enum_format, > .vidioc_g_fmt_vid_cap =3D aspeed_video_get_format, > - .vidioc_s_fmt_vid_cap =3D aspeed_video_get_format, > + .vidioc_s_fmt_vid_cap =3D aspeed_video_set_format, > .vidioc_try_fmt_vid_cap =3D aspeed_video_get_format, > =20 > .vidioc_reqbufs =3D vb2_ioctl_reqbufs, > @@ -1486,27 +1649,6 @@ static const struct v4l2_ioctl_ops aspeed_video_io= ctl_ops =3D { > .vidioc_unsubscribe_event =3D v4l2_event_unsubscribe, > }; > =20 > -static void aspeed_video_update_jpeg_quality(struct aspeed_video *video) > -{ > - u32 comp_ctrl =3D FIELD_PREP(VE_COMP_CTRL_DCT_LUM, video->jpeg_quality)= | > - FIELD_PREP(VE_COMP_CTRL_DCT_CHR, video->jpeg_quality | 0x10); > - > - aspeed_video_update(video, VE_COMP_CTRL, > - VE_COMP_CTRL_DCT_LUM | VE_COMP_CTRL_DCT_CHR, > - comp_ctrl); > -} > - > -static void aspeed_video_update_subsampling(struct aspeed_video *video) > -{ > - if (video->jpeg.virt) > - aspeed_video_update_jpeg_table(video->jpeg.virt, video->yuv420); > - > - if (video->yuv420) > - aspeed_video_update(video, VE_SEQ_CTRL, 0, VE_SEQ_CTRL_YUV420); > - else > - aspeed_video_update(video, VE_SEQ_CTRL, VE_SEQ_CTRL_YUV420, 0); > -} > - > static int aspeed_video_set_ctrl(struct v4l2_ctrl *ctrl) > { > struct aspeed_video *video =3D container_of(ctrl->handler, > @@ -1516,16 +1658,23 @@ static int aspeed_video_set_ctrl(struct v4l2_ctrl= *ctrl) > switch (ctrl->id) { > case V4L2_CID_JPEG_COMPRESSION_QUALITY: > video->jpeg_quality =3D ctrl->val; > - aspeed_video_update_jpeg_quality(video); > + if (test_bit(VIDEO_STREAMING, &video->flags)) > + aspeed_video_update_regs(video); > break; > case V4L2_CID_JPEG_CHROMA_SUBSAMPLING: > - if (ctrl->val =3D=3D V4L2_JPEG_CHROMA_SUBSAMPLING_420) { > - video->yuv420 =3D true; > - aspeed_video_update_subsampling(video); > - } else { > - video->yuv420 =3D false; > - aspeed_video_update_subsampling(video); > - } > + video->yuv420 =3D (ctrl->val =3D=3D V4L2_JPEG_CHROMA_SUBSAMPLING_420); > + if (test_bit(VIDEO_STREAMING, &video->flags)) > + aspeed_video_update_regs(video); > + break; > + case V4L2_CID_ASPEED_HQ_MODE: > + video->hq_mode =3D ctrl->val; > + if (test_bit(VIDEO_STREAMING, &video->flags)) > + aspeed_video_update_regs(video); > + break; > + case V4L2_CID_ASPEED_HQ_JPEG_QUALITY: > + video->jpeg_hq_quality =3D ctrl->val; > + if (test_bit(VIDEO_STREAMING, &video->flags)) > + aspeed_video_update_regs(video); > break; > default: > return -EINVAL; > @@ -1538,6 +1687,28 @@ static const struct v4l2_ctrl_ops aspeed_video_ctr= l_ops =3D { > .s_ctrl =3D aspeed_video_set_ctrl, > }; > =20 > +static const struct v4l2_ctrl_config aspeed_ctrl_HQ_mode =3D { > + .ops =3D &aspeed_video_ctrl_ops, > + .id =3D V4L2_CID_ASPEED_HQ_MODE, > + .name =3D "Aspeed HQ Mode", > + .type =3D V4L2_CTRL_TYPE_BOOLEAN, > + .min =3D false, > + .max =3D true, > + .step =3D 1, > + .def =3D false, > +}; > + > +static const struct v4l2_ctrl_config aspeed_ctrl_HQ_jpeg_quality =3D { > + .ops =3D &aspeed_video_ctrl_ops, > + .id =3D V4L2_CID_ASPEED_HQ_JPEG_QUALITY, > + .name =3D "Aspeed HQ Quality", > + .type =3D V4L2_CTRL_TYPE_INTEGER, > + .min =3D 1, > + .max =3D ASPEED_VIDEO_JPEG_NUM_QUALITIES, > + .step =3D 1, > + .def =3D 1, > +}; > + > static void aspeed_video_resolution_work(struct work_struct *work) > { > struct delayed_work *dwork =3D to_delayed_work(work); > @@ -1552,6 +1723,8 @@ static void aspeed_video_resolution_work(struct wor= k_struct *work) > =20 > aspeed_video_init_regs(video); > =20 > + aspeed_video_update_regs(video); > + > aspeed_video_get_resolution(video); > =20 > if (video->detected_timings.width !=3D video->active_timings.width || > @@ -1662,6 +1835,8 @@ static int aspeed_video_start_streaming(struct vb2_= queue *q, > video->perf.duration_max =3D 0; > video->perf.duration_min =3D 0xffffffff; > =20 > + aspeed_video_update_regs(video); > + > rc =3D aspeed_video_start_frame(video); > if (rc) { > aspeed_video_bufs_done(video, VB2_BUF_STATE_QUEUED); > @@ -1800,6 +1975,7 @@ static int aspeed_video_setup_video(struct aspeed_v= ideo *video) > struct v4l2_device *v4l2_dev =3D &video->v4l2_dev; > struct vb2_queue *vbq =3D &video->queue; > struct video_device *vdev =3D &video->vdev; > + struct v4l2_ctrl_handler *hdl =3D &video->ctrl_handler; > int rc; > =20 > video->pix_fmt.pixelformat =3D V4L2_PIX_FMT_JPEG; > @@ -1814,16 +1990,18 @@ static int aspeed_video_setup_video(struct aspeed= _video *video) > return rc; > } > =20 > - v4l2_ctrl_handler_init(&video->ctrl_handler, 2); > - v4l2_ctrl_new_std(&video->ctrl_handler, &aspeed_video_ctrl_ops, > + v4l2_ctrl_handler_init(hdl, 4); > + v4l2_ctrl_new_std(hdl, &aspeed_video_ctrl_ops, > V4L2_CID_JPEG_COMPRESSION_QUALITY, 0, > ASPEED_VIDEO_JPEG_NUM_QUALITIES - 1, 1, 0); > - v4l2_ctrl_new_std_menu(&video->ctrl_handler, &aspeed_video_ctrl_ops, > + v4l2_ctrl_new_std_menu(hdl, &aspeed_video_ctrl_ops, > V4L2_CID_JPEG_CHROMA_SUBSAMPLING, > V4L2_JPEG_CHROMA_SUBSAMPLING_420, mask, > V4L2_JPEG_CHROMA_SUBSAMPLING_444); > + v4l2_ctrl_new_custom(hdl, &aspeed_ctrl_HQ_mode, NULL); > + v4l2_ctrl_new_custom(hdl, &aspeed_ctrl_HQ_jpeg_quality, NULL); > =20 > - rc =3D video->ctrl_handler.error; > + rc =3D hdl->error; > if (rc) { > v4l2_ctrl_handler_free(&video->ctrl_handler); > v4l2_device_unregister(v4l2_dev); > @@ -1832,7 +2010,7 @@ static int aspeed_video_setup_video(struct aspeed_v= ideo *video) > return rc; > } > =20 > - v4l2_dev->ctrl_handler =3D &video->ctrl_handler; > + v4l2_dev->ctrl_handler =3D hdl; > =20 > vbq->type =3D V4L2_BUF_TYPE_VIDEO_CAPTURE; > vbq->io_modes =3D VB2_MMAP | VB2_READ | VB2_DMABUF; > @@ -1980,6 +2158,7 @@ static int aspeed_video_probe(struct platform_devic= e *pdev) > video->comp_size_read =3D config->comp_size_read; > =20 > video->frame_rate =3D 30; > + video->jpeg_hq_quality =3D 1; > video->dev =3D &pdev->dev; > spin_lock_init(&video->lock); > mutex_init(&video->video_lock); > diff --git a/include/uapi/linux/aspeed-video.h b/include/uapi/linux/aspee= d-video.h > new file mode 100644 > index 000000000000..63f0432192a5 > --- /dev/null > +++ b/include/uapi/linux/aspeed-video.h > @@ -0,0 +1,15 @@ > +/* SPDX-License-Identifier: GPL-2.0-or-later */ > +/* > + * Copyright (C) 2021 ASPEED Technology Inc. > + */ > + > +#ifndef _UAPI_LINUX_ASPEED_VIDEO_H > +#define _UAPI_LINUX_ASPEED_VIDEO_H > + > +#include > + > +#define V4L2_CID_ASPEED_COMPRESSION_SCHEME (V4L2_CID_USER_ASPEED_BASE += 1) > +#define V4L2_CID_ASPEED_HQ_MODE (V4L2_CID_USER_ASPEED_BASE + 2) > +#define V4L2_CID_ASPEED_HQ_JPEG_QUALITY (V4L2_CID_USER_ASPEED_BASE + 3= ) I believe you are missing documentation for these. Even vendor CID get to b= e documented in the RST doc, it also helps us reviewer to judge if these are trully vendor controls or should be generalized, its not currently possible= to make an opinion. > + > +#endif /* _UAPI_LINUX_ASPEED_VIDEO_H */ From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id D7E54C433FE for ; Tue, 18 Oct 2022 15:22:07 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Date:To:From:Subject:Message-ID:Reply-To:Cc:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=ntgHSWV/AHDKtfATzJkPAxF1VasXcvUW8i9I/9q5010=; b=iBH7LAR6sblFqo amrhxkqvX5XSd7TFTOtj9q10C3VDeCcj/47Rlzic+LOI5Nv/5HeWBq4q2wSTzxbJgbJ34/9oo5dDY nphJYXEB9521Y5+Wu6+PMdiyejzztc7wG3EJlvSS80ZpVS6KyV/DhUKklgshn2usYccUKKUBSPZ80 C/r7WtyWJ5P6aMr9BidB0eAqjQpMaQQmk5GjZ+zy6DvFoHMKKld3upE+bHDH42jUPtwsEqVffFN9+ ODyonwqV3P7mJnZP5CxsIIO2s34WP7XDEgIdCXzXLguPsC9Dp//9HIJNKc9tb454Wi+pzfFQEayL8 94YoIdH8vKza05gSEhZQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1okoOS-007Xbt-6y; Tue, 18 Oct 2022 15:20:37 +0000 Received: from madras.collabora.co.uk ([2a00:1098:0:82:1000:25:2eeb:e5ab]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1okoOJ-007XVO-VA for linux-arm-kernel@lists.infradead.org; Tue, 18 Oct 2022 15:20:31 +0000 Received: from nicolas-tpx395.localdomain (192-222-136-102.qc.cable.ebox.net [192.222.136.102]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) (Authenticated sender: nicolas) by madras.collabora.co.uk (Postfix) with ESMTPSA id A8681660035C; Tue, 18 Oct 2022 16:20:22 +0100 (BST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=collabora.com; s=mail; t=1666106424; bh=hcGU7f2VWGhlcxE4rVQ+mVCpg2sdCRIPSaRmUZxYE0A=; h=Subject:From:To:Date:In-Reply-To:References:From; b=KYd0rpCB1h0ybwIZP/sZD7SPX5E9qw5ofpBKQIn00e+WHIPBQumpLISuQNVhEkHmP LU8RoMV3iAoYwTMuNPcgPsfTd0IJz9gdeQMIusMzJuFUtL/4jd1OEPDS0iw0hjZGPk E7Zl/eCC3kxAANA6ZfuVwC7R4gAMf7nfzoKamKWsbJCYhzLwqs9mg+P7+X20cAqRw/ z2GyJAlgew02RseuUuFa5mqipVU6pGLVJGKPwnpahh+b2NYvsUrJIag/XrLT8/WE4h aQRj9oxYzCy52mpE+ZueAGx3HGIO2jfq1nXIpyu0eIimIzITtmwwvuswm4Sl9MlSHN izmAkcWfvdzhg== Message-ID: Subject: Re: [PATCH v9 3/4] media: aspeed: Support aspeed mode to reduce compressed data From: Nicolas Dufresne To: Jammy Huang , eajames@linux.ibm.com, mchehab@kernel.org, joel@jms.id.au, andrew@aj.id.au, linux-media@vger.kernel.org, openbmc@lists.ozlabs.org, linux-arm-kernel@lists.infradead.org, linux-aspeed@lists.ozlabs.org, linux-kernel@vger.kernel.org, hverkuil-cisco@xs4all.nl, ezequiel@vanguardiasur.com.ar, stanimir.varbanov@linaro.org, laurent.pinchart@ideasonboard.com, sakari.ailus@linux.intel.com, ribalda@chromium.org Date: Tue, 18 Oct 2022 11:20:13 -0400 In-Reply-To: <20220921025112.13150-4-jammy_huang@aspeedtech.com> References: <20220921025112.13150-1-jammy_huang@aspeedtech.com> <20220921025112.13150-4-jammy_huang@aspeedtech.com> User-Agent: Evolution 3.44.4 (3.44.4-2.fc36) MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20221018_082028_352906_E95E6EAB X-CRM114-Status: GOOD ( 33.87 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org SGksCgpMZSBtZXJjcmVkaSAyMSBzZXB0ZW1icmUgMjAyMiDDoCAxMDo1MSArMDgwMCwgSmFtbXkg SHVhbmcgYSDDqWNyaXTCoDoKPiBhc3BlZWQgc3VwcG9ydHMgZGlmZmVyZW50aWFsIGpwZWcgZm9y bWF0IHdoaWNoIG9ubHkgY29tcHJlc3MgdGhlIHBhcnRzCj4gd2hpY2ggYXJlIGNoYW5nZWQuIElu IHRoaXMgd2F5LCBpdCByZWR1Y2VzIGJvdGggdGhlIGFtb3VudCBvZiBkYXRhIHRvIGJlCj4gdHJh bnNmZXJyZWQgYnkgbmV0d29yayBhbmQgdGhvc2UgdG8gYmUgZGVjb2RlZCBvbiB0aGUgY2xpZW50 IHNpZGUuCj4gCj4gMiBuZXcgY3RybHMgYXJlIGFkZGVkOgo+ICogQXNwZWVkIEhRIE1vZGU6IHRv IGNvbnRyb2wgYXNwZWVkJ3MgaGlnaCBxdWFsaXR5KDItcGFzcykgY29tcHJlc3Npb24gbW9kZQo+ ICAgVGhpcyBvbmx5IHdvcmtzIHdpdGggeXV2NDQ0IHN1YnNhbXBsaW5nLgo+ICogQXNwZWVkIEhR IFF1YWxpdHk6IHRvIGNvbnRyb2wgdGhlIHF1YWxpdHkgb2YgYXNwZWVkJ3MgSFEgbW9kZQo+ICAg b25seSB1c2VmdWwgaWYgQXNwZWVkIEhRIG1vZGUgaXMgZW5hYmxlZAo+IAo+IEFzcGVlZCBKUEVH IEZvcm1hdCByZXF1aXJlcyBhbiBhZGRpdGlvbmFsIGJ1ZmZlciwgY2FsbGVkIGJjZCwgdG8gc3Rv cmUKPiB0aGUgaW5mb3JtYXRpb24gYWJvdXQgd2hpY2ggbWFjcm8gYmxvY2sgaW4gdGhlIG5ldyBm cmFtZSBpcyBkaWZmZXJlbnQKPiBmcm9tIHRoZSBwcmV2aW91cyBvbmUuCj4gCj4gVG8gaGF2ZSBi Y2QgY29ycmVjdGx5IHdvcmtpbmcsIHdlIG5lZWQgdG8gc3dhcCB0aGUgYnVmZmVycyBmb3Igc3Jj MC8xIHRvCj4gbWFrZSBzcmMxIHJlZmVyIHRvIHByZXZpb3VzIGZyYW1lIGFuZCBzcmMwIHRvIHRo ZSBjb21pbmcgbmV3IGZyYW1lLgo+IAo+IFNpZ25lZC1vZmYtYnk6IEphbW15IEh1YW5nIDxqYW1t eV9odWFuZ0Bhc3BlZWR0ZWNoLmNvbT4KPiAtLS0KPiAgZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9h c3BlZWQvYXNwZWVkLXZpZGVvLmMgfCAyODEgKysrKysrKysrKysrKysrLS0tLQo+ICBpbmNsdWRl L3VhcGkvbGludXgvYXNwZWVkLXZpZGVvLmggICAgICAgICAgICB8ICAxNSArCj4gIDIgZmlsZXMg Y2hhbmdlZCwgMjQ1IGluc2VydGlvbnMoKyksIDUxIGRlbGV0aW9ucygtKQo+ICBjcmVhdGUgbW9k ZSAxMDA2NDQgaW5jbHVkZS91YXBpL2xpbnV4L2FzcGVlZC12aWRlby5oCj4gCj4gZGlmZiAtLWdp dCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vYXNwZWVkL2FzcGVlZC12aWRlby5jIGIvZHJpdmVy cy9tZWRpYS9wbGF0Zm9ybS9hc3BlZWQvYXNwZWVkLXZpZGVvLmMKPiBpbmRleCAyMGY3OTVjY2Mx MWIuLjczOTI4ODAyNjQxOCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL2Fz cGVlZC9hc3BlZWQtdmlkZW8uYwo+ICsrKyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vYXNwZWVk L2FzcGVlZC12aWRlby5jCj4gQEAgLTMzLDYgKzMzLDcgQEAKPiAgI2luY2x1ZGUgPG1lZGlhL3Y0 bDItZXZlbnQuaD4KPiAgI2luY2x1ZGUgPG1lZGlhL3Y0bDItaW9jdGwuaD4KPiAgI2luY2x1ZGUg PG1lZGlhL3ZpZGVvYnVmMi1kbWEtY29udGlnLmg+Cj4gKyNpbmNsdWRlIDx1YXBpL2xpbnV4L2Fz cGVlZC12aWRlby5oPgo+ICAKPiAgI2RlZmluZSBBU1BFRURfVklERU9fVjRMMl9NSU5fQlVGX1JF USAzCj4gIAo+IEBAIC01OSw2ICs2MCw3IEBACj4gIAo+ICAjZGVmaW5lIFZFX01BWF9TUkNfQlVG RkVSX1NJWkUJCTB4OGNhMDAwIC8qIDE5MjAgKiAxMjAwLCAzMmJwcCAqLwo+ICAjZGVmaW5lIFZF X0pQRUdfSEVBREVSX1NJWkUJCTB4MDA2MDAwIC8qIDUxMiAqIDEyICogNCAqLwo+ICsjZGVmaW5l IFZFX0JDRF9CVUZGX1NJWkUJCTB4OTAwMCAvKiAoMTkyMC84KSAqICgxMjAwLzgpICovCj4gIAo+ ICAjZGVmaW5lIFZFX1BST1RFQ1RJT05fS0VZCQkweDAwMAo+ICAjZGVmaW5lICBWRV9QUk9URUNU SU9OX0tFWV9VTkxPQ0sJMHgxYTAzOGFhOAo+IEBAIC0xMDcsNiArMTA5LDEzIEBACj4gICNkZWZp bmUgVkVfU0NBTElOR19GSUxURVIyCQkweDAyMAo+ICAjZGVmaW5lIFZFX1NDQUxJTkdfRklMVEVS MwkJMHgwMjQKPiAgCj4gKyNkZWZpbmUgVkVfQkNEX0NUUkwJCQkweDAyQwo+ICsjZGVmaW5lICBW RV9CQ0RfQ1RSTF9FTl9CQ0QJCUJJVCgwKQo+ICsjZGVmaW5lICBWRV9CQ0RfQ1RSTF9FTl9BQkNE CQlCSVQoMSkKPiArI2RlZmluZSAgVkVfQkNEX0NUUkxfRU5fQ0IJCUJJVCgyKQo+ICsjZGVmaW5l ICBWRV9CQ0RfQ1RSTF9USFIJCUdFTk1BU0soMjMsIDE2KQo+ICsjZGVmaW5lICBWRV9CQ0RfQ1RS TF9BQkNEX1RIUgkJR0VOTUFTSygzMSwgMjQpCj4gKwo+ICAjZGVmaW5lIFZFX0NBUF9XSU5ET1cJ CQkweDAzMAo+ICAjZGVmaW5lIFZFX0NPTVBfV0lORE9XCQkJMHgwMzQKPiAgI2RlZmluZSBWRV9D T01QX1BST0NfT0ZGU0VUCQkweDAzOAo+IEBAIC0xMTUsNiArMTI0LDcgQEAKPiAgI2RlZmluZSBW RV9TUkMwX0FERFIJCQkweDA0NAo+ICAjZGVmaW5lIFZFX1NSQ19TQ0FOTElORV9PRkZTRVQJCTB4 MDQ4Cj4gICNkZWZpbmUgVkVfU1JDMV9BRERSCQkJMHgwNGMKPiArI2RlZmluZSBWRV9CQ0RfQURE UgkJCTB4MDUwCj4gICNkZWZpbmUgVkVfQ09NUF9BRERSCQkJMHgwNTQKPiAgCj4gICNkZWZpbmUg VkVfU1RSRUFNX0JVRl9TSVpFCQkweDA1OAo+IEBAIC0xMzUsNiArMTQ1LDggQEAKPiAgI2RlZmlu ZSAgVkVfQ09NUF9DVFJMX0hRX0RDVF9DSFIJR0VOTUFTSygyNiwgMjIpCj4gICNkZWZpbmUgIFZF X0NPTVBfQ1RSTF9IUV9EQ1RfTFVNCUdFTk1BU0soMzEsIDI3KQo+ICAKPiArI2RlZmluZSBWRV9D Ql9BRERSCQkJMHgwNkMKPiArCj4gICNkZWZpbmUgQVNUMjQwMF9WRV9DT01QX1NJWkVfUkVBRF9C QUNLCTB4MDc4Cj4gICNkZWZpbmUgQVNUMjYwMF9WRV9DT01QX1NJWkVfUkVBRF9CQUNLCTB4MDg0 Cj4gIAo+IEBAIC0yMTEsNiArMjIzLDEyIEBAIGVudW0gewo+ICAJVklERU9fQ0xPQ0tTX09OLAo+ ICB9Owo+ICAKPiArZW51bSBhc3BlZWRfdmlkZW9fZm9ybWF0IHsKPiArCVZJREVPX0ZNVF9TVEFO REFSRCA9IDAsCj4gKwlWSURFT19GTVRfQVNQRUVELAo+ICsJVklERU9fRk1UX01BWCA9IFZJREVP X0ZNVF9BU1BFRUQKPiArfTsKPiArCj4gIC8vIGZvciBWRV9DVFJMX0NBUFRVUkVfRk1UCj4gIGVu dW0gYXNwZWVkX3ZpZGVvX2NhcHR1cmVfZm9ybWF0IHsKPiAgCVZJREVPX0NBUF9GTVRfWVVWX1NU VURJT19TV0lORyA9IDAsCj4gQEAgLTI0NSwxNiArMjYzLDIwIEBAIHN0cnVjdCBhc3BlZWRfdmlk ZW9fcGVyZiB7Cj4gIC8qCj4gICAqIHN0cnVjdCBhc3BlZWRfdmlkZW8gLSBkcml2ZXIgZGF0YQo+ ICAgKgo+IC0gKiByZXNfd29yazogICAgICAgICAgIGhvbGRzIHRoZSBkZWxheWVkX3dvcmsgZm9y IHJlcy1kZXRlY3Rpb24gaWYgdW5sb2NrCj4gLSAqIGJ1ZmZlcnM6ICAgICAgICAgICAgaG9sZHMg dGhlIGxpc3Qgb2YgYnVmZmVyIHF1ZXVlZCBmcm9tIHVzZXIKPiArICogcmVzX3dvcms6CQlob2xk cyB0aGUgZGVsYXllZF93b3JrIGZvciByZXMtZGV0ZWN0aW9uIGlmIHVubG9jawo+ICsgKiBidWZm ZXJzOgkJaG9sZHMgdGhlIGxpc3Qgb2YgYnVmZmVyIHF1ZXVlZCBmcm9tIHVzZXIKPiAgICogZmxh Z3M6CQlob2xkcyB0aGUgc3RhdGUgb2YgdmlkZW8KPiAgICogc2VxdWVuY2U6CQlob2xkcyB0aGUg bGFzdCBudW1iZXIgb2YgZnJhbWUgY29tcGxldGVkCj4gICAqIG1heF9jb21wcmVzc2VkX3NpemU6 CWhvbGRzIG1heCBjb21wcmVzc2VkIHN0cmVhbSdzIHNpemUKPiAgICogc3JjczoJCWhvbGRzIHRo ZSBidWZmZXIgaW5mb3JtYXRpb24gZm9yIHNyY3MKPiAgICoganBlZzoJCWhvbGRzIHRoZSBidWZm ZXIgaW5mb3JtYXRpb24gZm9yIGpwZWcgaGVhZGVyCj4gKyAqIGJjZDoJCQlob2xkcyB0aGUgYnVm ZmVyIGluZm9ybWF0aW9uIGZvciBiY2Qgd29yawo+ICAgKiB5dXY0MjA6CQlhIGZsYWcgcmFpc2Vk IGlmIEpQRUcgc3Vic2FtcGxpbmcgaXMgNDIwCj4gKyAqIGZvcm1hdDoJCWhvbGRzIHRoZSB2aWRl byBmb3JtYXQKPiArICogaHFfbW9kZToJCWEgZmxhZyByYWlzZWQgaWYgSFEgaXMgZW5hYmxlZC4g T25seSBmb3IgVklERU9fRk1UX0FTUEVFRAo+ICAgKiBmcmFtZV9yYXRlOgkJaG9sZHMgdGhlIGZy YW1lX3JhdGUKPiAgICoganBlZ19xdWFsaXR5Oglob2xkcyBqcGVxJ3MgcXVhbGl0eSAoMH4xMSkK PiArICoganBlZ19ocV9xdWFsaXR5Oglob2xkcyBocSdzIHF1YWxpdHkgKDF+MTIpIG9ubHkgaWYg aHFfbW9kZSBlbmFibGVkCj4gICAqIGZyYW1lX2JvdHRvbToJZW5kIHBvc2l0aW9uIG9mIHZpZGVv IGRhdGEgaW4gdmVydGljYWwgZGlyZWN0aW9uCj4gICAqIGZyYW1lX2xlZnQ6CQlzdGFydCBwb3Np dGlvbiBvZiB2aWRlbyBkYXRhIGluIGhvcml6b250YWwgZGlyZWN0aW9uCj4gICAqIGZyYW1lX3Jp Z2h0OgkJZW5kIHBvc2l0aW9uIG9mIHZpZGVvIGRhdGEgaW4gaG9yaXpvbnRhbCBkaXJlY3Rpb24K PiBAQCAtMjkwLDEwICszMTIsMTQgQEAgc3RydWN0IGFzcGVlZF92aWRlbyB7Cj4gIAl1bnNpZ25l ZCBpbnQgbWF4X2NvbXByZXNzZWRfc2l6ZTsKPiAgCXN0cnVjdCBhc3BlZWRfdmlkZW9fYWRkciBz cmNzWzJdOwo+ICAJc3RydWN0IGFzcGVlZF92aWRlb19hZGRyIGpwZWc7Cj4gKwlzdHJ1Y3QgYXNw ZWVkX3ZpZGVvX2FkZHIgYmNkOwo+ICAKPiAgCWJvb2wgeXV2NDIwOwo+ICsJZW51bSBhc3BlZWRf dmlkZW9fZm9ybWF0IGZvcm1hdDsKPiArCWJvb2wgaHFfbW9kZTsKPiAgCXVuc2lnbmVkIGludCBm cmFtZV9yYXRlOwo+ICAJdW5zaWduZWQgaW50IGpwZWdfcXVhbGl0eTsKPiArCXVuc2lnbmVkIGlu dCBqcGVnX2hxX3F1YWxpdHk7Cj4gIAo+ICAJdW5zaWduZWQgaW50IGZyYW1lX2JvdHRvbTsKPiAg CXVuc2lnbmVkIGludCBmcmFtZV9sZWZ0Owo+IEBAIC00NTgsOCArNDg0LDIwIEBAIHN0YXRpYyBj b25zdCBzdHJ1Y3QgdjRsMl9kdl90aW1pbmdzX2NhcCBhc3BlZWRfdmlkZW9fdGltaW5nc19jYXAg PSB7Cj4gIAl9LAo+ICB9Owo+ICAKPiArc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBjb21wcmVz c19zY2hlbWVfc3RyW10gPSB7IkRDVCBPbmx5IiwKPiArCSJEQ1QgVlEgbWl4IDItY29sb3IiLCAi RENUIFZRIG1peCA0LWNvbG9yIn07Cj4gK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZm9ybWF0 X3N0cltdID0geyJTdGFuZGFyZCBKUEVHIiwKPiArCSJBc3BlZWQgSlBFRyJ9Owo+ICsKPiAgc3Rh dGljIHVuc2lnbmVkIGludCBkZWJ1ZzsKPiAgCj4gK3N0YXRpYyBib29sIGFzcGVlZF92aWRlb19h bGxvY19idWYoc3RydWN0IGFzcGVlZF92aWRlbyAqdmlkZW8sCj4gKwkJCQkgICBzdHJ1Y3QgYXNw ZWVkX3ZpZGVvX2FkZHIgKmFkZHIsCj4gKwkJCQkgICB1bnNpZ25lZCBpbnQgc2l6ZSk7Cj4gKwo+ ICtzdGF0aWMgdm9pZCBhc3BlZWRfdmlkZW9fZnJlZV9idWYoc3RydWN0IGFzcGVlZF92aWRlbyAq dmlkZW8sCj4gKwkJCQkgIHN0cnVjdCBhc3BlZWRfdmlkZW9fYWRkciAqYWRkcik7Cj4gKwo+ICBz dGF0aWMgdm9pZCBhc3BlZWRfdmlkZW9faW5pdF9qcGVnX3RhYmxlKHUzMiAqdGFibGUsIGJvb2wg eXV2NDIwKQo+ICB7Cj4gIAlpbnQgaTsKPiBAQCAtNTQ3LDYgKzU4NSw3IEBAIHN0YXRpYyBpbnQg YXNwZWVkX3ZpZGVvX3N0YXJ0X2ZyYW1lKHN0cnVjdCBhc3BlZWRfdmlkZW8gKnZpZGVvKQo+ICAJ dW5zaWduZWQgbG9uZyBmbGFnczsKPiAgCXN0cnVjdCBhc3BlZWRfdmlkZW9fYnVmZmVyICpidWY7 Cj4gIAl1MzIgc2VxX2N0cmwgPSBhc3BlZWRfdmlkZW9fcmVhZCh2aWRlbywgVkVfU0VRX0NUUkwp Owo+ICsJYm9vbCBiY2RfYnVmX25lZWQgPSAodmlkZW8tPmZvcm1hdCAhPSBWSURFT19GTVRfU1RB TkRBUkQpOwo+ICAKPiAgCWlmICh2aWRlby0+djRsMl9pbnB1dF9zdGF0dXMpIHsKPiAgCQl2NGwy X3dhcm4oJnZpZGVvLT52NGwyX2RldiwgIk5vIHNpZ25hbDsgZG9uJ3Qgc3RhcnQgZnJhbWVcbiIp Owo+IEBAIC01NTksNiArNTk4LDIwIEBAIHN0YXRpYyBpbnQgYXNwZWVkX3ZpZGVvX3N0YXJ0X2Zy YW1lKHN0cnVjdCBhc3BlZWRfdmlkZW8gKnZpZGVvKQo+ICAJCXJldHVybiAtRUJVU1k7Cj4gIAl9 Cj4gIAo+ICsJaWYgKGJjZF9idWZfbmVlZCAmJiAhdmlkZW8tPmJjZC5zaXplKSB7Cj4gKwkJaWYg KCFhc3BlZWRfdmlkZW9fYWxsb2NfYnVmKHZpZGVvLCAmdmlkZW8tPmJjZCwKPiArCQkJCQkgICAg VkVfQkNEX0JVRkZfU0laRSkpIHsKPiArCQkJZGV2X2Vycih2aWRlby0+ZGV2LCAiRmFpbGVkIHRv IGFsbG9jYXRlIEJDRCBidWZmZXJcbiIpOwo+ICsJCQlkZXZfZXJyKHZpZGVvLT5kZXYsICJkb24n dCBzdGFydCBmcmFtZVxuIik7Cj4gKwkJCXJldHVybiAtRU5PTUVNOwo+ICsJCX0KPiArCQlhc3Bl ZWRfdmlkZW9fd3JpdGUodmlkZW8sIFZFX0JDRF9BRERSLCB2aWRlby0+YmNkLmRtYSk7Cj4gKwkJ djRsMl9kYmcoMSwgZGVidWcsICZ2aWRlby0+djRsMl9kZXYsICJiY2QgYWRkciglI3gpIHNpemUo JWQpXG4iLAo+ICsJCQkgdmlkZW8tPmJjZC5kbWEsIHZpZGVvLT5iY2Quc2l6ZSk7Cj4gKwl9IGVs c2UgaWYgKCFiY2RfYnVmX25lZWQgJiYgdmlkZW8tPmJjZC5zaXplKSB7Cj4gKwkJYXNwZWVkX3Zp ZGVvX2ZyZWVfYnVmKHZpZGVvLCAmdmlkZW8tPmJjZCk7Cj4gKwl9Cj4gKwo+ICAJc3Bpbl9sb2Nr X2lycXNhdmUoJnZpZGVvLT5sb2NrLCBmbGFncyk7Cj4gIAlidWYgPSBsaXN0X2ZpcnN0X2VudHJ5 X29yX251bGwoJnZpZGVvLT5idWZmZXJzLAo+ICAJCQkJICAgICAgIHN0cnVjdCBhc3BlZWRfdmlk ZW9fYnVmZmVyLCBsaW5rKTsKPiBAQCAtNjU3LDYgKzcxMCwyNCBAQCBzdGF0aWMgdm9pZCBhc3Bl ZWRfdmlkZW9faXJxX3Jlc19jaGFuZ2Uoc3RydWN0IGFzcGVlZF92aWRlbyAqdmlkZW8sIHVsb25n IGRlbGF5KQo+ICAJc2NoZWR1bGVfZGVsYXllZF93b3JrKCZ2aWRlby0+cmVzX3dvcmssIGRlbGF5 KTsKPiAgfQo+ICAKPiArc3RhdGljIHZvaWQgYXNwZWVkX3ZpZGVvX3N3YXBfc3JjX2J1ZihzdHJ1 Y3QgYXNwZWVkX3ZpZGVvICp2KQo+ICt7Cj4gKwlpZiAodi0+Zm9ybWF0ID09IFZJREVPX0ZNVF9T VEFOREFSRCkKPiArCQlyZXR1cm47Cj4gKwo+ICsJLyogUmVzZXQgYmNkIGJ1ZmZlciB0byBoYXZl IGEgZnVsbCBmcmFtZSB1cGRhdGUgZXZlcnkgOCBmcmFtZXMuICAqLwo+ICsJaWYgKElTX0FMSUdO RUQodi0+c2VxdWVuY2UsIDgpKQo+ICsJCW1lbXNldCgodTggKil2LT5iY2QudmlydCwgMHgwMCwg VkVfQkNEX0JVRkZfU0laRSk7Cj4gKwo+ICsJaWYgKHYtPnNlcXVlbmNlICYgMHgwMSkgewo+ICsJ CWFzcGVlZF92aWRlb193cml0ZSh2LCBWRV9TUkMwX0FERFIsIHYtPnNyY3NbMV0uZG1hKTsKPiAr CQlhc3BlZWRfdmlkZW9fd3JpdGUodiwgVkVfU1JDMV9BRERSLCB2LT5zcmNzWzBdLmRtYSk7Cj4g Kwl9IGVsc2Ugewo+ICsJCWFzcGVlZF92aWRlb193cml0ZSh2LCBWRV9TUkMwX0FERFIsIHYtPnNy Y3NbMF0uZG1hKTsKPiArCQlhc3BlZWRfdmlkZW9fd3JpdGUodiwgVkVfU1JDMV9BRERSLCB2LT5z cmNzWzFdLmRtYSk7Cj4gKwl9Cj4gK30KPiArCj4gIHN0YXRpYyBpcnFyZXR1cm5fdCBhc3BlZWRf dmlkZW9faXJxKGludCBpcnEsIHZvaWQgKmFyZykKPiAgewo+ICAJc3RydWN0IGFzcGVlZF92aWRl byAqdmlkZW8gPSBhcmc7Cj4gQEAgLTcwNSw2ICs3NzYsNyBAQCBzdGF0aWMgaXJxcmV0dXJuX3Qg YXNwZWVkX3ZpZGVvX2lycShpbnQgaXJxLCB2b2lkICphcmcpCj4gIAo+ICAJaWYgKHN0cyAmIFZF X0lOVEVSUlVQVF9DT01QX0NPTVBMRVRFKSB7Cj4gIAkJc3RydWN0IGFzcGVlZF92aWRlb19idWZm ZXIgKmJ1ZjsKPiArCQlib29sIGVtcHR5ID0gdHJ1ZTsKPiAgCQl1MzIgZnJhbWVfc2l6ZSA9IGFz cGVlZF92aWRlb19yZWFkKHZpZGVvLAo+ICAJCQkJCQkgICB2aWRlby0+Y29tcF9zaXplX3JlYWQp Owo+ICAKPiBAQCAtNzE4LDEzICs3OTAsMjMgQEAgc3RhdGljIGlycXJldHVybl90IGFzcGVlZF92 aWRlb19pcnEoaW50IGlycSwgdm9pZCAqYXJnKQo+ICAJCWlmIChidWYpIHsKPiAgCQkJdmIyX3Nl dF9wbGFuZV9wYXlsb2FkKCZidWYtPnZiLnZiMl9idWYsIDAsIGZyYW1lX3NpemUpOwo+ICAKPiAt CQkJaWYgKCFsaXN0X2lzX2xhc3QoJmJ1Zi0+bGluaywgJnZpZGVvLT5idWZmZXJzKSkgewo+ICsJ CQkvKgo+ICsJCQkgKiBhc3BlZWRfanBlZyByZXF1aXJlcyBjb250aW51b3VzIHVwZGF0ZS4KPiAr CQkJICogT24gdGhlIGNvbnRyYXJ5LCBzdGFuZGFyZCBqcGVnIGNhbiBrZWVwIGxhc3QgYnVmZmVy Cj4gKwkJCSAqIHRvIGFsd2F5cyBoYXZlIHRoZSBsYXRlc3QgcmVzdWx0Lgo+ICsJCQkgKi8KPiAr CQkJaWYgKHZpZGVvLT5mb3JtYXQgPT0gVklERU9fRk1UX1NUQU5EQVJEICYmCj4gKwkJCSAgICBs aXN0X2lzX2xhc3QoJmJ1Zi0+bGluaywgJnZpZGVvLT5idWZmZXJzKSkgewo+ICsJCQkJZW1wdHkg PSBmYWxzZTsKPiArCQkJCXY0bDJfd2FybigmdmlkZW8tPnY0bDJfZGV2LCAic2tpcCB0byBrZWVw IGxhc3QgZnJhbWUgdXBkYXRlZFxuIik7Cj4gKwkJCX0gZWxzZSB7Cj4gIAkJCQlidWYtPnZiLnZi Ml9idWYudGltZXN0YW1wID0ga3RpbWVfZ2V0X25zKCk7Cj4gIAkJCQlidWYtPnZiLnNlcXVlbmNl ID0gdmlkZW8tPnNlcXVlbmNlKys7Cj4gIAkJCQlidWYtPnZiLmZpZWxkID0gVjRMMl9GSUVMRF9O T05FOwo+ICAJCQkJdmIyX2J1ZmZlcl9kb25lKCZidWYtPnZiLnZiMl9idWYsCj4gIAkJCQkJCVZC Ml9CVUZfU1RBVEVfRE9ORSk7Cj4gIAkJCQlsaXN0X2RlbCgmYnVmLT5saW5rKTsKPiArCQkJCWVt cHR5ID0gbGlzdF9lbXB0eSgmdmlkZW8tPmJ1ZmZlcnMpOwo+ICAJCQl9Cj4gIAkJfQo+ICAJCXNw aW5fdW5sb2NrKCZ2aWRlby0+bG9jayk7Cj4gQEAgLTczOCw3ICs4MjAsMTAgQEAgc3RhdGljIGly cXJldHVybl90IGFzcGVlZF92aWRlb19pcnEoaW50IGlycSwgdm9pZCAqYXJnKQo+ICAJCWFzcGVl ZF92aWRlb193cml0ZSh2aWRlbywgVkVfSU5URVJSVVBUX1NUQVRVUywKPiAgCQkJCSAgIFZFX0lO VEVSUlVQVF9DT01QX0NPTVBMRVRFKTsKPiAgCQlzdHMgJj0gflZFX0lOVEVSUlVQVF9DT01QX0NP TVBMRVRFOwo+IC0JCWlmICh0ZXN0X2JpdChWSURFT19TVFJFQU1JTkcsICZ2aWRlby0+ZmxhZ3Mp ICYmIGJ1ZikKPiArCj4gKwkJYXNwZWVkX3ZpZGVvX3N3YXBfc3JjX2J1Zih2aWRlbyk7Cj4gKwo+ ICsJCWlmICh0ZXN0X2JpdChWSURFT19TVFJFQU1JTkcsICZ2aWRlby0+ZmxhZ3MpICYmICFlbXB0 eSkKPiAgCQkJYXNwZWVkX3ZpZGVvX3N0YXJ0X2ZyYW1lKHZpZGVvKTsKPiAgCX0KPiAgCj4gQEAg LTEwODUsMTAgKzExNzAsMTQgQEAgc3RhdGljIHZvaWQgYXNwZWVkX3ZpZGVvX3NldF9yZXNvbHV0 aW9uKHN0cnVjdCBhc3BlZWRfdmlkZW8gKnZpZGVvKQo+ICAJCQkJICAgRklFTERfUFJFUChWRV9U R1NfRklSU1QsIHZpZGVvLT5mcmFtZV90b3ApIHwKPiAgCQkJCSAgIEZJRUxEX1BSRVAoVkVfVEdT X0xBU1QsCj4gIAkJCQkJICAgICAgdmlkZW8tPmZyYW1lX2JvdHRvbSArIDEpKTsKPiAtCQlhc3Bl ZWRfdmlkZW9fdXBkYXRlKHZpZGVvLCBWRV9DVFJMLCAwLCBWRV9DVFJMX0lOVF9ERSk7Cj4gKwkJ YXNwZWVkX3ZpZGVvX3VwZGF0ZSh2aWRlbywgVkVfQ1RSTCwKPiArCQkJCSAgICBWRV9DVFJMX0lO VF9ERSB8IFZFX0NUUkxfRElSRUNUX0ZFVENILAo+ICsJCQkJICAgIFZFX0NUUkxfSU5UX0RFKTsK PiAgCX0gZWxzZSB7Cj4gIAkJdjRsMl9kYmcoMSwgZGVidWcsICZ2aWRlby0+djRsMl9kZXYsICJD YXB0dXJlOiBEaXJlY3QgTW9kZVxuIik7Cj4gLQkJYXNwZWVkX3ZpZGVvX3VwZGF0ZSh2aWRlbywg VkVfQ1RSTCwgMCwgVkVfQ1RSTF9ESVJFQ1RfRkVUQ0gpOwo+ICsJCWFzcGVlZF92aWRlb191cGRh dGUodmlkZW8sIFZFX0NUUkwsCj4gKwkJCQkgICAgVkVfQ1RSTF9JTlRfREUgfCBWRV9DVFJMX0RJ UkVDVF9GRVRDSCwKPiArCQkJCSAgICBWRV9DVFJMX0RJUkVDVF9GRVRDSCk7Cj4gIAl9Cj4gIAo+ ICAJc2l6ZSAqPSA0Owo+IEBAIC0xMTIxLDIxICsxMjEwLDY2IEBAIHN0YXRpYyB2b2lkIGFzcGVl ZF92aWRlb19zZXRfcmVzb2x1dGlvbihzdHJ1Y3QgYXNwZWVkX3ZpZGVvICp2aWRlbykKPiAgCQlh c3BlZWRfdmlkZW9fZnJlZV9idWYodmlkZW8sICZ2aWRlby0+c3Jjc1swXSk7Cj4gIH0KPiAgCj4g LXN0YXRpYyB2b2lkIGFzcGVlZF92aWRlb19pbml0X3JlZ3Moc3RydWN0IGFzcGVlZF92aWRlbyAq dmlkZW8pCj4gK3N0YXRpYyB2b2lkIGFzcGVlZF92aWRlb191cGRhdGVfcmVncyhzdHJ1Y3QgYXNw ZWVkX3ZpZGVvICp2aWRlbykKPiAgewo+IC0JdTMyIGNvbXBfY3RybCA9IFZFX0NPTVBfQ1RSTF9S U1ZEIHwKPiAtCQlGSUVMRF9QUkVQKFZFX0NPTVBfQ1RSTF9EQ1RfTFVNLCB2aWRlby0+anBlZ19x dWFsaXR5KSB8Cj4gLQkJRklFTERfUFJFUChWRV9DT01QX0NUUkxfRENUX0NIUiwgdmlkZW8tPmpw ZWdfcXVhbGl0eSB8IDB4MTApOwo+IC0JdTMyIGN0cmwgPSBWRV9DVFJMX0FVVE9fT1JfQ1VSU09S IHwKPiAtCQlGSUVMRF9QUkVQKFZFX0NUUkxfQ0FQVFVSRV9GTVQsIFZJREVPX0NBUF9GTVRfWVVW X0ZVTExfU1dJTkcpOwo+IC0JdTMyIHNlcV9jdHJsID0gdmlkZW8tPmpwZWdfbW9kZTsKPiArCXU4 IGpwZWdfaHFfcXVhbGl0eSA9IGNsYW1wKChpbnQpdmlkZW8tPmpwZWdfaHFfcXVhbGl0eSAtIDEs IDAsCj4gKwkJCQkgICBBU1BFRURfVklERU9fSlBFR19OVU1fUVVBTElUSUVTIC0gMSk7Cj4gKwl1 MzIgY29tcF9jdHJsID0JRklFTERfUFJFUChWRV9DT01QX0NUUkxfRENUX0xVTSwgdmlkZW8tPmpw ZWdfcXVhbGl0eSkgfAo+ICsJCUZJRUxEX1BSRVAoVkVfQ09NUF9DVFJMX0RDVF9DSFIsIHZpZGVv LT5qcGVnX3F1YWxpdHkgfCAweDEwKSB8Cj4gKwkJRklFTERfUFJFUChWRV9DT01QX0NUUkxfRU5f SFEsIHZpZGVvLT5ocV9tb2RlKSB8Cj4gKwkJRklFTERfUFJFUChWRV9DT01QX0NUUkxfSFFfRENU X0xVTSwganBlZ19ocV9xdWFsaXR5KSB8Cj4gKwkJRklFTERfUFJFUChWRV9DT01QX0NUUkxfSFFf RENUX0NIUiwganBlZ19ocV9xdWFsaXR5IHwgMHgxMCk7Cj4gKwl1MzIgY3RybCA9IDA7Cj4gKwl1 MzIgc2VxX2N0cmwgPSAwOwo+ICsKPiArCXY0bDJfZGJnKDEsIGRlYnVnLCAmdmlkZW8tPnY0bDJf ZGV2LCAiZnJhbWVyYXRlKCVkKVxuIiwKPiArCQkgdmlkZW8tPmZyYW1lX3JhdGUpOwo+ICsJdjRs Ml9kYmcoMSwgZGVidWcsICZ2aWRlby0+djRsMl9kZXYsICJqcGVnIGZvcm1hdCglcykgc3Vic2Ft cGxlKCVzKVxuIiwKPiArCQkgZm9ybWF0X3N0clt2aWRlby0+Zm9ybWF0XSwKPiArCQkgdmlkZW8t Pnl1djQyMCA/ICI0MjAiIDogIjQ0NCIpOwo+ICsJdjRsMl9kYmcoMSwgZGVidWcsICZ2aWRlby0+ djRsMl9kZXYsICJjb21wcmVzc2lvbiBxdWFsaXR5KCVkKVxuIiwKPiArCQkgdmlkZW8tPmpwZWdf cXVhbGl0eSk7Cj4gKwl2NGwyX2RiZygxLCBkZWJ1ZywgJnZpZGVvLT52NGwyX2RldiwgImhxX21v ZGUoJXMpIGhxX3F1YWxpdHkoJWQpXG4iLAo+ICsJCSB2aWRlby0+aHFfbW9kZSA/ICJvbiIgOiAi b2ZmIiwgdmlkZW8tPmpwZWdfaHFfcXVhbGl0eSk7Cj4gKwo+ICsJaWYgKHZpZGVvLT5mb3JtYXQg PT0gVklERU9fRk1UX0FTUEVFRCkKPiArCQlhc3BlZWRfdmlkZW9fdXBkYXRlKHZpZGVvLCBWRV9C Q0RfQ1RSTCwgMCwgVkVfQkNEX0NUUkxfRU5fQkNEKTsKPiArCWVsc2UKPiArCQlhc3BlZWRfdmlk ZW9fdXBkYXRlKHZpZGVvLCBWRV9CQ0RfQ1RSTCwgVkVfQkNEX0NUUkxfRU5fQkNELCAwKTsKPiAg Cj4gIAlpZiAodmlkZW8tPmZyYW1lX3JhdGUpCj4gIAkJY3RybCB8PSBGSUVMRF9QUkVQKFZFX0NU UkxfRlJDLCB2aWRlby0+ZnJhbWVfcmF0ZSk7Cj4gIAo+ICsJaWYgKHZpZGVvLT5mb3JtYXQgPT0g VklERU9fRk1UX1NUQU5EQVJEKSB7Cj4gKwkJY29tcF9jdHJsICY9IH5GSUVMRF9QUkVQKFZFX0NP TVBfQ1RSTF9FTl9IUSwgdmlkZW8tPmhxX21vZGUpOwo+ICsJCXNlcV9jdHJsIHw9IHZpZGVvLT5q cGVnX21vZGU7Cj4gKwl9Cj4gKwo+ICAJaWYgKHZpZGVvLT55dXY0MjApCj4gIAkJc2VxX2N0cmwg fD0gVkVfU0VRX0NUUkxfWVVWNDIwOwo+ICAKPiArCWlmICh2aWRlby0+anBlZy52aXJ0KQo+ICsJ CWFzcGVlZF92aWRlb191cGRhdGVfanBlZ190YWJsZSh2aWRlby0+anBlZy52aXJ0LCB2aWRlby0+ eXV2NDIwKTsKPiArCj4gKwo+ICsJLyogU2V0IGNvbnRyb2wgcmVnaXN0ZXJzICovCj4gKwlhc3Bl ZWRfdmlkZW9fdXBkYXRlKHZpZGVvLCBWRV9TRVFfQ1RSTCwKPiArCQkJICAgIHZpZGVvLT5qcGVn X21vZGUgfCBWRV9TRVFfQ1RSTF9ZVVY0MjAsCj4gKwkJCSAgICBzZXFfY3RybCk7Cj4gKwlhc3Bl ZWRfdmlkZW9fdXBkYXRlKHZpZGVvLCBWRV9DVFJMLCBWRV9DVFJMX0ZSQywgY3RybCk7Cj4gKwlh c3BlZWRfdmlkZW9fdXBkYXRlKHZpZGVvLCBWRV9DT01QX0NUUkwsCj4gKwkJCSAgICBWRV9DT01Q X0NUUkxfRENUX0xVTSB8IFZFX0NPTVBfQ1RSTF9EQ1RfQ0hSIHwKPiArCQkJICAgIFZFX0NPTVBf Q1RSTF9FTl9IUSB8IFZFX0NPTVBfQ1RSTF9IUV9EQ1RfTFVNIHwKPiArCQkJICAgIFZFX0NPTVBf Q1RSTF9IUV9EQ1RfQ0hSIHwgVkVfQ09NUF9DVFJMX1ZRXzRDT0xPUiB8Cj4gKwkJCSAgICBWRV9D T01QX0NUUkxfVlFfRENUX09OTFksCj4gKwkJCSAgICBjb21wX2N0cmwpOwo+ICt9Cj4gKwo+ICtz dGF0aWMgdm9pZCBhc3BlZWRfdmlkZW9faW5pdF9yZWdzKHN0cnVjdCBhc3BlZWRfdmlkZW8gKnZp ZGVvKQo+ICt7Cj4gKwl1MzIgY3RybCA9IFZFX0NUUkxfQVVUT19PUl9DVVJTT1IgfAo+ICsJCUZJ RUxEX1BSRVAoVkVfQ1RSTF9DQVBUVVJFX0ZNVCwgVklERU9fQ0FQX0ZNVF9ZVVZfRlVMTF9TV0lO Ryk7Cj4gKwo+ICAJLyogVW5sb2NrIFZFIHJlZ2lzdGVycyAqLwo+ICAJYXNwZWVkX3ZpZGVvX3dy aXRlKHZpZGVvLCBWRV9QUk9URUNUSU9OX0tFWSwgVkVfUFJPVEVDVElPTl9LRVlfVU5MT0NLKTsK PiAgCj4gQEAgLTExNTAsOSArMTI4NCw4IEBAIHN0YXRpYyB2b2lkIGFzcGVlZF92aWRlb19pbml0 X3JlZ3Moc3RydWN0IGFzcGVlZF92aWRlbyAqdmlkZW8pCj4gIAlhc3BlZWRfdmlkZW9fd3JpdGUo dmlkZW8sIFZFX0pQRUdfQUREUiwgdmlkZW8tPmpwZWcuZG1hKTsKPiAgCj4gIAkvKiBTZXQgY29u dHJvbCByZWdpc3RlcnMgKi8KPiAtCWFzcGVlZF92aWRlb193cml0ZSh2aWRlbywgVkVfU0VRX0NU UkwsIHNlcV9jdHJsKTsKPiAgCWFzcGVlZF92aWRlb193cml0ZSh2aWRlbywgVkVfQ1RSTCwgY3Ry bCk7Cj4gLQlhc3BlZWRfdmlkZW9fd3JpdGUodmlkZW8sIFZFX0NPTVBfQ1RSTCwgY29tcF9jdHJs KTsKPiArCWFzcGVlZF92aWRlb193cml0ZSh2aWRlbywgVkVfQ09NUF9DVFJMLCBWRV9DT01QX0NU UkxfUlNWRCk7Cj4gIAo+ICAJLyogRG9uJ3QgZG93bnNjYWxlICovCj4gIAlhc3BlZWRfdmlkZW9f d3JpdGUodmlkZW8sIFZFX1NDQUxJTkdfRkFDVE9SLCAweDEwMDAxMDAwKTsKPiBAQCAtMTE2OCw2 ICsxMzAxLDggQEAgc3RhdGljIHZvaWQgYXNwZWVkX3ZpZGVvX2luaXRfcmVncyhzdHJ1Y3QgYXNw ZWVkX3ZpZGVvICp2aWRlbykKPiAgCQkJICAgRklFTERfUFJFUChWRV9NT0RFX0RUX0hPUl9TVEFC TEUsIDYpIHwKPiAgCQkJICAgRklFTERfUFJFUChWRV9NT0RFX0RUX1ZFUl9TVEFCTEUsIDYpIHwK PiAgCQkJICAgRklFTERfUFJFUChWRV9NT0RFX0RUX0VER19USFJPRCwgMHg2NSkpOwo+ICsKPiAr CWFzcGVlZF92aWRlb193cml0ZSh2aWRlbywgVkVfQkNEX0NUUkwsIDApOwo+ICB9Cj4gIAo+ICBz dGF0aWMgdm9pZCBhc3BlZWRfdmlkZW9fc3RhcnQoc3RydWN0IGFzcGVlZF92aWRlbyAqdmlkZW8p Cj4gQEAgLTEyMDEsNiArMTMzNiw5IEBAIHN0YXRpYyB2b2lkIGFzcGVlZF92aWRlb19zdG9wKHN0 cnVjdCBhc3BlZWRfdmlkZW8gKnZpZGVvKQo+ICAJaWYgKHZpZGVvLT5zcmNzWzFdLnNpemUpCj4g IAkJYXNwZWVkX3ZpZGVvX2ZyZWVfYnVmKHZpZGVvLCAmdmlkZW8tPnNyY3NbMV0pOwo+ICAKPiAr CWlmICh2aWRlby0+YmNkLnNpemUpCj4gKwkJYXNwZWVkX3ZpZGVvX2ZyZWVfYnVmKHZpZGVvLCAm dmlkZW8tPmJjZCk7Cj4gKwo+ICAJdmlkZW8tPnY0bDJfaW5wdXRfc3RhdHVzID0gVjRMMl9JTl9T VF9OT19TSUdOQUw7Cj4gIAl2aWRlby0+ZmxhZ3MgPSAwOwo+ICB9Cj4gQEAgLTEyMTksMTAgKzEz NTcsMTIgQEAgc3RhdGljIGludCBhc3BlZWRfdmlkZW9fcXVlcnljYXAoc3RydWN0IGZpbGUgKmZp bGUsIHZvaWQgKmZoLAo+ICBzdGF0aWMgaW50IGFzcGVlZF92aWRlb19lbnVtX2Zvcm1hdChzdHJ1 Y3QgZmlsZSAqZmlsZSwgdm9pZCAqZmgsCj4gIAkJCQkgICAgc3RydWN0IHY0bDJfZm10ZGVzYyAq ZikKPiAgewo+ICsJc3RydWN0IGFzcGVlZF92aWRlbyAqdmlkZW8gPSB2aWRlb19kcnZkYXRhKGZp bGUpOwo+ICsKPiAgCWlmIChmLT5pbmRleCkKPiAgCQlyZXR1cm4gLUVJTlZBTDsKPiAgCj4gLQlm LT5waXhlbGZvcm1hdCA9IFY0TDJfUElYX0ZNVF9KUEVHOwo+ICsJZi0+cGl4ZWxmb3JtYXQgPSB2 aWRlby0+cGl4X2ZtdC5waXhlbGZvcm1hdDsKPiAgCj4gIAlyZXR1cm4gMDsKPiAgfQo+IEBAIC0x MjM3LDYgKzEzNzcsMjkgQEAgc3RhdGljIGludCBhc3BlZWRfdmlkZW9fZ2V0X2Zvcm1hdChzdHJ1 Y3QgZmlsZSAqZmlsZSwgdm9pZCAqZmgsCj4gIAlyZXR1cm4gMDsKPiAgfQo+ICAKPiArc3RhdGlj IGludCBhc3BlZWRfdmlkZW9fc2V0X2Zvcm1hdChzdHJ1Y3QgZmlsZSAqZmlsZSwgdm9pZCAqZmgs Cj4gKwkJCQkgICBzdHJ1Y3QgdjRsMl9mb3JtYXQgKmYpCj4gK3sKPiArCXN0cnVjdCBhc3BlZWRf dmlkZW8gKnZpZGVvID0gdmlkZW9fZHJ2ZGF0YShmaWxlKTsKPiArCj4gKwlpZiAodmIyX2lzX2J1 c3koJnZpZGVvLT5xdWV1ZSkpCj4gKwkJcmV0dXJuIC1FQlVTWTsKPiArCj4gKwlzd2l0Y2ggKGYt PmZtdC5waXgucGl4ZWxmb3JtYXQpIHsKPiArCWNhc2UgVjRMMl9QSVhfRk1UX0pQRUc6Cj4gKwkJ dmlkZW8tPmZvcm1hdCA9IFZJREVPX0ZNVF9TVEFOREFSRDsKPiArCQlicmVhazsKPiArCWNhc2Ug VjRMMl9QSVhfRk1UX0FKUEc6Cj4gKwkJdmlkZW8tPmZvcm1hdCA9IFZJREVPX0ZNVF9BU1BFRUQ7 Cj4gKwkJYnJlYWs7Cj4gKwlkZWZhdWx0Ogo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsJfQo+ICsJ dmlkZW8tPnBpeF9mbXQucGl4ZWxmb3JtYXQgPSBmLT5mbXQucGl4LnBpeGVsZm9ybWF0Owo+ICsK PiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICBzdGF0aWMgaW50IGFzcGVlZF92aWRlb19lbnVtX2lu cHV0KHN0cnVjdCBmaWxlICpmaWxlLCB2b2lkICpmaCwKPiAgCQkJCSAgIHN0cnVjdCB2NGwyX2lu cHV0ICppbnApCj4gIHsKPiBAQCAtMTQ1NCw3ICsxNjE3LDcgQEAgc3RhdGljIGNvbnN0IHN0cnVj dCB2NGwyX2lvY3RsX29wcyBhc3BlZWRfdmlkZW9faW9jdGxfb3BzID0gewo+ICAKPiAgCS52aWRp b2NfZW51bV9mbXRfdmlkX2NhcCA9IGFzcGVlZF92aWRlb19lbnVtX2Zvcm1hdCwKPiAgCS52aWRp b2NfZ19mbXRfdmlkX2NhcCA9IGFzcGVlZF92aWRlb19nZXRfZm9ybWF0LAo+IC0JLnZpZGlvY19z X2ZtdF92aWRfY2FwID0gYXNwZWVkX3ZpZGVvX2dldF9mb3JtYXQsCj4gKwkudmlkaW9jX3NfZm10 X3ZpZF9jYXAgPSBhc3BlZWRfdmlkZW9fc2V0X2Zvcm1hdCwKPiAgCS52aWRpb2NfdHJ5X2ZtdF92 aWRfY2FwID0gYXNwZWVkX3ZpZGVvX2dldF9mb3JtYXQsCj4gIAo+ICAJLnZpZGlvY19yZXFidWZz ID0gdmIyX2lvY3RsX3JlcWJ1ZnMsCj4gQEAgLTE0ODYsMjcgKzE2NDksNiBAQCBzdGF0aWMgY29u c3Qgc3RydWN0IHY0bDJfaW9jdGxfb3BzIGFzcGVlZF92aWRlb19pb2N0bF9vcHMgPSB7Cj4gIAku dmlkaW9jX3Vuc3Vic2NyaWJlX2V2ZW50ID0gdjRsMl9ldmVudF91bnN1YnNjcmliZSwKPiAgfTsK PiAgCj4gLXN0YXRpYyB2b2lkIGFzcGVlZF92aWRlb191cGRhdGVfanBlZ19xdWFsaXR5KHN0cnVj dCBhc3BlZWRfdmlkZW8gKnZpZGVvKQo+IC17Cj4gLQl1MzIgY29tcF9jdHJsID0gRklFTERfUFJF UChWRV9DT01QX0NUUkxfRENUX0xVTSwgdmlkZW8tPmpwZWdfcXVhbGl0eSkgfAo+IC0JCUZJRUxE X1BSRVAoVkVfQ09NUF9DVFJMX0RDVF9DSFIsIHZpZGVvLT5qcGVnX3F1YWxpdHkgfCAweDEwKTsK PiAtCj4gLQlhc3BlZWRfdmlkZW9fdXBkYXRlKHZpZGVvLCBWRV9DT01QX0NUUkwsCj4gLQkJCSAg ICBWRV9DT01QX0NUUkxfRENUX0xVTSB8IFZFX0NPTVBfQ1RSTF9EQ1RfQ0hSLAo+IC0JCQkgICAg Y29tcF9jdHJsKTsKPiAtfQo+IC0KPiAtc3RhdGljIHZvaWQgYXNwZWVkX3ZpZGVvX3VwZGF0ZV9z dWJzYW1wbGluZyhzdHJ1Y3QgYXNwZWVkX3ZpZGVvICp2aWRlbykKPiAtewo+IC0JaWYgKHZpZGVv LT5qcGVnLnZpcnQpCj4gLQkJYXNwZWVkX3ZpZGVvX3VwZGF0ZV9qcGVnX3RhYmxlKHZpZGVvLT5q cGVnLnZpcnQsIHZpZGVvLT55dXY0MjApOwo+IC0KPiAtCWlmICh2aWRlby0+eXV2NDIwKQo+IC0J CWFzcGVlZF92aWRlb191cGRhdGUodmlkZW8sIFZFX1NFUV9DVFJMLCAwLCBWRV9TRVFfQ1RSTF9Z VVY0MjApOwo+IC0JZWxzZQo+IC0JCWFzcGVlZF92aWRlb191cGRhdGUodmlkZW8sIFZFX1NFUV9D VFJMLCBWRV9TRVFfQ1RSTF9ZVVY0MjAsIDApOwo+IC19Cj4gLQo+ICBzdGF0aWMgaW50IGFzcGVl ZF92aWRlb19zZXRfY3RybChzdHJ1Y3QgdjRsMl9jdHJsICpjdHJsKQo+ICB7Cj4gIAlzdHJ1Y3Qg YXNwZWVkX3ZpZGVvICp2aWRlbyA9IGNvbnRhaW5lcl9vZihjdHJsLT5oYW5kbGVyLAo+IEBAIC0x NTE2LDE2ICsxNjU4LDIzIEBAIHN0YXRpYyBpbnQgYXNwZWVkX3ZpZGVvX3NldF9jdHJsKHN0cnVj dCB2NGwyX2N0cmwgKmN0cmwpCj4gIAlzd2l0Y2ggKGN0cmwtPmlkKSB7Cj4gIAljYXNlIFY0TDJf Q0lEX0pQRUdfQ09NUFJFU1NJT05fUVVBTElUWToKPiAgCQl2aWRlby0+anBlZ19xdWFsaXR5ID0g Y3RybC0+dmFsOwo+IC0JCWFzcGVlZF92aWRlb191cGRhdGVfanBlZ19xdWFsaXR5KHZpZGVvKTsK PiArCQlpZiAodGVzdF9iaXQoVklERU9fU1RSRUFNSU5HLCAmdmlkZW8tPmZsYWdzKSkKPiArCQkJ YXNwZWVkX3ZpZGVvX3VwZGF0ZV9yZWdzKHZpZGVvKTsKPiAgCQlicmVhazsKPiAgCWNhc2UgVjRM Ml9DSURfSlBFR19DSFJPTUFfU1VCU0FNUExJTkc6Cj4gLQkJaWYgKGN0cmwtPnZhbCA9PSBWNEwy X0pQRUdfQ0hST01BX1NVQlNBTVBMSU5HXzQyMCkgewo+IC0JCQl2aWRlby0+eXV2NDIwID0gdHJ1 ZTsKPiAtCQkJYXNwZWVkX3ZpZGVvX3VwZGF0ZV9zdWJzYW1wbGluZyh2aWRlbyk7Cj4gLQkJfSBl bHNlIHsKPiAtCQkJdmlkZW8tPnl1djQyMCA9IGZhbHNlOwo+IC0JCQlhc3BlZWRfdmlkZW9fdXBk YXRlX3N1YnNhbXBsaW5nKHZpZGVvKTsKPiAtCQl9Cj4gKwkJdmlkZW8tPnl1djQyMCA9IChjdHJs LT52YWwgPT0gVjRMMl9KUEVHX0NIUk9NQV9TVUJTQU1QTElOR180MjApOwo+ICsJCWlmICh0ZXN0 X2JpdChWSURFT19TVFJFQU1JTkcsICZ2aWRlby0+ZmxhZ3MpKQo+ICsJCQlhc3BlZWRfdmlkZW9f dXBkYXRlX3JlZ3ModmlkZW8pOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSBWNEwyX0NJRF9BU1BFRURf SFFfTU9ERToKPiArCQl2aWRlby0+aHFfbW9kZSA9IGN0cmwtPnZhbDsKPiArCQlpZiAodGVzdF9i aXQoVklERU9fU1RSRUFNSU5HLCAmdmlkZW8tPmZsYWdzKSkKPiArCQkJYXNwZWVkX3ZpZGVvX3Vw ZGF0ZV9yZWdzKHZpZGVvKTsKPiArCQlicmVhazsKPiArCWNhc2UgVjRMMl9DSURfQVNQRUVEX0hR X0pQRUdfUVVBTElUWToKPiArCQl2aWRlby0+anBlZ19ocV9xdWFsaXR5ID0gY3RybC0+dmFsOwo+ ICsJCWlmICh0ZXN0X2JpdChWSURFT19TVFJFQU1JTkcsICZ2aWRlby0+ZmxhZ3MpKQo+ICsJCQlh c3BlZWRfdmlkZW9fdXBkYXRlX3JlZ3ModmlkZW8pOwo+ICAJCWJyZWFrOwo+ICAJZGVmYXVsdDoK PiAgCQlyZXR1cm4gLUVJTlZBTDsKPiBAQCAtMTUzOCw2ICsxNjg3LDI4IEBAIHN0YXRpYyBjb25z dCBzdHJ1Y3QgdjRsMl9jdHJsX29wcyBhc3BlZWRfdmlkZW9fY3RybF9vcHMgPSB7Cj4gIAkuc19j dHJsID0gYXNwZWVkX3ZpZGVvX3NldF9jdHJsLAo+ICB9Owo+ICAKPiArc3RhdGljIGNvbnN0IHN0 cnVjdCB2NGwyX2N0cmxfY29uZmlnIGFzcGVlZF9jdHJsX0hRX21vZGUgPSB7Cj4gKwkub3BzID0g JmFzcGVlZF92aWRlb19jdHJsX29wcywKPiArCS5pZCA9IFY0TDJfQ0lEX0FTUEVFRF9IUV9NT0RF LAo+ICsJLm5hbWUgPSAiQXNwZWVkIEhRIE1vZGUiLAo+ICsJLnR5cGUgPSBWNEwyX0NUUkxfVFlQ RV9CT09MRUFOLAo+ICsJLm1pbiA9IGZhbHNlLAo+ICsJLm1heCA9IHRydWUsCj4gKwkuc3RlcCA9 IDEsCj4gKwkuZGVmID0gZmFsc2UsCj4gK307Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IHY0 bDJfY3RybF9jb25maWcgYXNwZWVkX2N0cmxfSFFfanBlZ19xdWFsaXR5ID0gewo+ICsJLm9wcyA9 ICZhc3BlZWRfdmlkZW9fY3RybF9vcHMsCj4gKwkuaWQgPSBWNEwyX0NJRF9BU1BFRURfSFFfSlBF R19RVUFMSVRZLAo+ICsJLm5hbWUgPSAiQXNwZWVkIEhRIFF1YWxpdHkiLAo+ICsJLnR5cGUgPSBW NEwyX0NUUkxfVFlQRV9JTlRFR0VSLAo+ICsJLm1pbiA9IDEsCj4gKwkubWF4ID0gQVNQRUVEX1ZJ REVPX0pQRUdfTlVNX1FVQUxJVElFUywKPiArCS5zdGVwID0gMSwKPiArCS5kZWYgPSAxLAo+ICt9 Owo+ICsKPiAgc3RhdGljIHZvaWQgYXNwZWVkX3ZpZGVvX3Jlc29sdXRpb25fd29yayhzdHJ1Y3Qg d29ya19zdHJ1Y3QgKndvcmspCj4gIHsKPiAgCXN0cnVjdCBkZWxheWVkX3dvcmsgKmR3b3JrID0g dG9fZGVsYXllZF93b3JrKHdvcmspOwo+IEBAIC0xNTUyLDYgKzE3MjMsOCBAQCBzdGF0aWMgdm9p ZCBhc3BlZWRfdmlkZW9fcmVzb2x1dGlvbl93b3JrKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykK PiAgCj4gIAlhc3BlZWRfdmlkZW9faW5pdF9yZWdzKHZpZGVvKTsKPiAgCj4gKwlhc3BlZWRfdmlk ZW9fdXBkYXRlX3JlZ3ModmlkZW8pOwo+ICsKPiAgCWFzcGVlZF92aWRlb19nZXRfcmVzb2x1dGlv bih2aWRlbyk7Cj4gIAo+ICAJaWYgKHZpZGVvLT5kZXRlY3RlZF90aW1pbmdzLndpZHRoICE9IHZp ZGVvLT5hY3RpdmVfdGltaW5ncy53aWR0aCB8fAo+IEBAIC0xNjYyLDYgKzE4MzUsOCBAQCBzdGF0 aWMgaW50IGFzcGVlZF92aWRlb19zdGFydF9zdHJlYW1pbmcoc3RydWN0IHZiMl9xdWV1ZSAqcSwK PiAgCXZpZGVvLT5wZXJmLmR1cmF0aW9uX21heCA9IDA7Cj4gIAl2aWRlby0+cGVyZi5kdXJhdGlv bl9taW4gPSAweGZmZmZmZmZmOwo+ICAKPiArCWFzcGVlZF92aWRlb191cGRhdGVfcmVncyh2aWRl byk7Cj4gKwo+ICAJcmMgPSBhc3BlZWRfdmlkZW9fc3RhcnRfZnJhbWUodmlkZW8pOwo+ICAJaWYg KHJjKSB7Cj4gIAkJYXNwZWVkX3ZpZGVvX2J1ZnNfZG9uZSh2aWRlbywgVkIyX0JVRl9TVEFURV9R VUVVRUQpOwo+IEBAIC0xODAwLDYgKzE5NzUsNyBAQCBzdGF0aWMgaW50IGFzcGVlZF92aWRlb19z ZXR1cF92aWRlbyhzdHJ1Y3QgYXNwZWVkX3ZpZGVvICp2aWRlbykKPiAgCXN0cnVjdCB2NGwyX2Rl dmljZSAqdjRsMl9kZXYgPSAmdmlkZW8tPnY0bDJfZGV2Owo+ICAJc3RydWN0IHZiMl9xdWV1ZSAq dmJxID0gJnZpZGVvLT5xdWV1ZTsKPiAgCXN0cnVjdCB2aWRlb19kZXZpY2UgKnZkZXYgPSAmdmlk ZW8tPnZkZXY7Cj4gKwlzdHJ1Y3QgdjRsMl9jdHJsX2hhbmRsZXIgKmhkbCA9ICZ2aWRlby0+Y3Ry bF9oYW5kbGVyOwo+ICAJaW50IHJjOwo+ICAKPiAgCXZpZGVvLT5waXhfZm10LnBpeGVsZm9ybWF0 ID0gVjRMMl9QSVhfRk1UX0pQRUc7Cj4gQEAgLTE4MTQsMTYgKzE5OTAsMTggQEAgc3RhdGljIGlu dCBhc3BlZWRfdmlkZW9fc2V0dXBfdmlkZW8oc3RydWN0IGFzcGVlZF92aWRlbyAqdmlkZW8pCj4g IAkJcmV0dXJuIHJjOwo+ICAJfQo+ICAKPiAtCXY0bDJfY3RybF9oYW5kbGVyX2luaXQoJnZpZGVv LT5jdHJsX2hhbmRsZXIsIDIpOwo+IC0JdjRsMl9jdHJsX25ld19zdGQoJnZpZGVvLT5jdHJsX2hh bmRsZXIsICZhc3BlZWRfdmlkZW9fY3RybF9vcHMsCj4gKwl2NGwyX2N0cmxfaGFuZGxlcl9pbml0 KGhkbCwgNCk7Cj4gKwl2NGwyX2N0cmxfbmV3X3N0ZChoZGwsICZhc3BlZWRfdmlkZW9fY3RybF9v cHMsCj4gIAkJCSAgVjRMMl9DSURfSlBFR19DT01QUkVTU0lPTl9RVUFMSVRZLCAwLAo+ICAJCQkg IEFTUEVFRF9WSURFT19KUEVHX05VTV9RVUFMSVRJRVMgLSAxLCAxLCAwKTsKPiAtCXY0bDJfY3Ry bF9uZXdfc3RkX21lbnUoJnZpZGVvLT5jdHJsX2hhbmRsZXIsICZhc3BlZWRfdmlkZW9fY3RybF9v cHMsCj4gKwl2NGwyX2N0cmxfbmV3X3N0ZF9tZW51KGhkbCwgJmFzcGVlZF92aWRlb19jdHJsX29w cywKPiAgCQkJICAgICAgIFY0TDJfQ0lEX0pQRUdfQ0hST01BX1NVQlNBTVBMSU5HLAo+ICAJCQkg ICAgICAgVjRMMl9KUEVHX0NIUk9NQV9TVUJTQU1QTElOR180MjAsIG1hc2ssCj4gIAkJCSAgICAg ICBWNEwyX0pQRUdfQ0hST01BX1NVQlNBTVBMSU5HXzQ0NCk7Cj4gKwl2NGwyX2N0cmxfbmV3X2N1 c3RvbShoZGwsICZhc3BlZWRfY3RybF9IUV9tb2RlLCBOVUxMKTsKPiArCXY0bDJfY3RybF9uZXdf Y3VzdG9tKGhkbCwgJmFzcGVlZF9jdHJsX0hRX2pwZWdfcXVhbGl0eSwgTlVMTCk7Cj4gIAo+IC0J cmMgPSB2aWRlby0+Y3RybF9oYW5kbGVyLmVycm9yOwo+ICsJcmMgPSBoZGwtPmVycm9yOwo+ICAJ aWYgKHJjKSB7Cj4gIAkJdjRsMl9jdHJsX2hhbmRsZXJfZnJlZSgmdmlkZW8tPmN0cmxfaGFuZGxl cik7Cj4gIAkJdjRsMl9kZXZpY2VfdW5yZWdpc3Rlcih2NGwyX2Rldik7Cj4gQEAgLTE4MzIsNyAr MjAxMCw3IEBAIHN0YXRpYyBpbnQgYXNwZWVkX3ZpZGVvX3NldHVwX3ZpZGVvKHN0cnVjdCBhc3Bl ZWRfdmlkZW8gKnZpZGVvKQo+ICAJCXJldHVybiByYzsKPiAgCX0KPiAgCj4gLQl2NGwyX2Rldi0+ Y3RybF9oYW5kbGVyID0gJnZpZGVvLT5jdHJsX2hhbmRsZXI7Cj4gKwl2NGwyX2Rldi0+Y3RybF9o YW5kbGVyID0gaGRsOwo+ICAKPiAgCXZicS0+dHlwZSA9IFY0TDJfQlVGX1RZUEVfVklERU9fQ0FQ VFVSRTsKPiAgCXZicS0+aW9fbW9kZXMgPSBWQjJfTU1BUCB8IFZCMl9SRUFEIHwgVkIyX0RNQUJV RjsKPiBAQCAtMTk4MCw2ICsyMTU4LDcgQEAgc3RhdGljIGludCBhc3BlZWRfdmlkZW9fcHJvYmUo c3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKPiAgCXZpZGVvLT5jb21wX3NpemVfcmVhZCA9 IGNvbmZpZy0+Y29tcF9zaXplX3JlYWQ7Cj4gIAo+ICAJdmlkZW8tPmZyYW1lX3JhdGUgPSAzMDsK PiArCXZpZGVvLT5qcGVnX2hxX3F1YWxpdHkgPSAxOwo+ICAJdmlkZW8tPmRldiA9ICZwZGV2LT5k ZXY7Cj4gIAlzcGluX2xvY2tfaW5pdCgmdmlkZW8tPmxvY2spOwo+ICAJbXV0ZXhfaW5pdCgmdmlk ZW8tPnZpZGVvX2xvY2spOwo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL3VhcGkvbGludXgvYXNwZWVk LXZpZGVvLmggYi9pbmNsdWRlL3VhcGkvbGludXgvYXNwZWVkLXZpZGVvLmgKPiBuZXcgZmlsZSBt b2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAwMC4uNjNmMDQzMjE5MmE1Cj4gLS0tIC9kZXYv bnVsbAo+ICsrKyBiL2luY2x1ZGUvdWFwaS9saW51eC9hc3BlZWQtdmlkZW8uaAo+IEBAIC0wLDAg KzEsMTUgQEAKPiArLyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAtb3ItbGF0ZXIg Ki8KPiArLyoKPiArICogQ29weXJpZ2h0IChDKSAyMDIxIEFTUEVFRCBUZWNobm9sb2d5IEluYy4K PiArICovCj4gKwo+ICsjaWZuZGVmIF9VQVBJX0xJTlVYX0FTUEVFRF9WSURFT19ICj4gKyNkZWZp bmUgX1VBUElfTElOVVhfQVNQRUVEX1ZJREVPX0gKPiArCj4gKyNpbmNsdWRlIDxsaW51eC92NGwy LWNvbnRyb2xzLmg+Cj4gKwo+ICsjZGVmaW5lIFY0TDJfQ0lEX0FTUEVFRF9DT01QUkVTU0lPTl9T Q0hFTUUJKFY0TDJfQ0lEX1VTRVJfQVNQRUVEX0JBU0UgICsgMSkKPiArI2RlZmluZSBWNEwyX0NJ RF9BU1BFRURfSFFfTU9ERQkJCShWNEwyX0NJRF9VU0VSX0FTUEVFRF9CQVNFICArIDIpCj4gKyNk ZWZpbmUgVjRMMl9DSURfQVNQRUVEX0hRX0pQRUdfUVVBTElUWQkJKFY0TDJfQ0lEX1VTRVJfQVNQ RUVEX0JBU0UgICsgMykKCkkgYmVsaWV2ZSB5b3UgYXJlIG1pc3NpbmcgZG9jdW1lbnRhdGlvbiBm b3IgdGhlc2UuIEV2ZW4gdmVuZG9yIENJRCBnZXQgdG8gYmUKZG9jdW1lbnRlZCBpbiB0aGUgUlNU IGRvYywgaXQgYWxzbyBoZWxwcyB1cyByZXZpZXdlciB0byBqdWRnZSBpZiB0aGVzZSBhcmUKdHJ1 bGx5IHZlbmRvciBjb250cm9scyBvciBzaG91bGQgYmUgZ2VuZXJhbGl6ZWQsIGl0cyBub3QgY3Vy cmVudGx5IHBvc3NpYmxlIHRvCm1ha2UgYW4gb3Bpbmlvbi4KCj4gKwo+ICsjZW5kaWYgLyogX1VB UElfTElOVVhfQVNQRUVEX1ZJREVPX0ggKi8KCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlzdApsaW51eC1h cm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcv bWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==