From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from relay4-d.mail.gandi.net (relay4-d.mail.gandi.net [217.70.183.196]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id F225F323F for ; Fri, 15 Apr 2022 15:28:41 +0000 (UTC) Received: (Authenticated sender: paul.kocialkowski@bootlin.com) by mail.gandi.net (Postfix) with ESMTPSA id 6CBC2E0013; Fri, 15 Apr 2022 15:28:39 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1650036520; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=jUjQaMo0gxDEGeQugoELE5k8zPMDdRJCPc5uVTwkmzg=; b=ahh+89EkZKgbAQctLoyxsu4eT/h/O6iwTyfCxCKLjgaxl5EbkZmqrgQfiswbT0AXXukP3x XDOfLIDr3DiEZHs0GP6uQi/wJxe/NrjIHyQyDiftX6davwszyqF4X6hRy0E7iQroVni5tT sBGgmty+VoX4cnfJn1bTSloRmy0R3Dni+FKd1ONEX0BS3S8/H49ExCkNSw+lO2WrKu2XQr NmAuHRwHCfIkBxpHxdcJ13O4RprXTgyW7AydKN5bwsPHAj8oi0zFAoTX351CXxZS8L2PBx t2oHosmakPLsPm3WKHYKjpLVOtG0FfPuNaLdfaHZxP1XVezTbem17O/b5PGtYQ== From: Paul Kocialkowski To: linux-kernel@vger.kernel.org, linux-media@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sunxi@lists.linux.dev Cc: Yong Deng , Paul Kocialkowski , Mauro Carvalho Chehab , Chen-Yu Tsai , Jernej Skrabec , Samuel Holland , Laurent Pinchart , Maxime Ripard , Thomas Petazzoni Subject: [PATCH v4 18/45] media: sun6i-csi: Add capture state using vsync for page flip Date: Fri, 15 Apr 2022 17:27:44 +0200 Message-Id: <20220415152811.636419-19-paul.kocialkowski@bootlin.com> X-Mailer: git-send-email 2.35.2 In-Reply-To: <20220415152811.636419-1-paul.kocialkowski@bootlin.com> References: <20220415152811.636419-1-paul.kocialkowski@bootlin.com> Precedence: bulk X-Mailing-List: linux-sunxi@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The current implementation requires up to 3 buffers to properly implement page flipping without losing frames: one is configured before the video stream is started, one just after that and page flipping is synchronized to the frame done interrupt. The comment in the code mentions that "CSI will lookup the next dma buffer for next frame before the current frame done IRQ triggered". Based on observations of the CSI unit behavior, it seems that the buffer DMA address is sampled when the frame scan begins (in addition to starting the stream), which corresponds to the vblank interrupt that hits just before the frame-done interrupt of the previous frame. As a result, the address configured at the frame done interrupt is not actually used for the next frame but for the one after that. This proposal changes the page flipping sync point to the vsync interrupt, which allows the DMA address to be sampled for the next frame instead and allows operating with only two buffers. In addition to the change in the sync point, the code is refactored to introduce a notion of state that clarifies tracking of the buffers with tidy functions. Signed-off-by: Paul Kocialkowski --- .../platform/sunxi/sun6i-csi/sun6i_csi.c | 4 + .../platform/sunxi/sun6i-csi/sun6i_csi.h | 3 - .../sunxi/sun6i-csi/sun6i_csi_capture.c | 259 ++++++++++-------- .../sunxi/sun6i-csi/sun6i_csi_capture.h | 23 +- 4 files changed, 165 insertions(+), 124 deletions(-) diff --git a/drivers/media/platform/sunxi/sun6i-csi/sun6i_csi.c b/drivers/media/platform/sunxi/sun6i-csi/sun6i_csi.c index 62f65867c771..5656faf15d7e 100644 --- a/drivers/media/platform/sunxi/sun6i-csi/sun6i_csi.c +++ b/drivers/media/platform/sunxi/sun6i-csi/sun6i_csi.c @@ -566,6 +566,7 @@ void sun6i_csi_set_stream(struct sun6i_csi_device *csi_dev, bool enable) regmap_write(regmap, CSI_CH_INT_STA_REG, 0xFF); regmap_write(regmap, CSI_CH_INT_EN_REG, + CSI_CH_INT_EN_VS_INT_EN | CSI_CH_INT_EN_HB_OF_INT_EN | CSI_CH_INT_EN_FIFO2_OF_INT_EN | CSI_CH_INT_EN_FIFO1_OF_INT_EN | @@ -679,6 +680,9 @@ static irqreturn_t sun6i_csi_interrupt(int irq, void *private) if (status & CSI_CH_INT_STA_FD_PD) sun6i_csi_capture_frame_done(csi_dev); + if (status & CSI_CH_INT_STA_VS_PD) + sun6i_csi_capture_sync(csi_dev); + regmap_write(regmap, CSI_CH_INT_STA_REG, status); return IRQ_HANDLED; diff --git a/drivers/media/platform/sunxi/sun6i-csi/sun6i_csi.h b/drivers/media/platform/sunxi/sun6i-csi/sun6i_csi.h index 422d7b9939f9..f02656dbfd84 100644 --- a/drivers/media/platform/sunxi/sun6i-csi/sun6i_csi.h +++ b/drivers/media/platform/sunxi/sun6i-csi/sun6i_csi.h @@ -26,9 +26,6 @@ enum sun6i_csi_port { struct sun6i_csi_buffer { struct vb2_v4l2_buffer v4l2_buffer; struct list_head list; - - dma_addr_t dma_addr; - bool queued_to_csi; }; /** diff --git a/drivers/media/platform/sunxi/sun6i-csi/sun6i_csi_capture.c b/drivers/media/platform/sunxi/sun6i-csi/sun6i_csi_capture.c index cb29ddf6af27..e227940cb66e 100644 --- a/drivers/media/platform/sunxi/sun6i-csi/sun6i_csi_capture.c +++ b/drivers/media/platform/sunxi/sun6i-csi/sun6i_csi_capture.c @@ -90,8 +90,13 @@ static void sun6i_csi_capture_buffer_configure(struct sun6i_csi_device *csi_dev, struct sun6i_csi_buffer *csi_buffer) { - csi_buffer->queued_to_csi = true; - sun6i_csi_update_buf_addr(csi_dev, csi_buffer->dma_addr); + struct vb2_buffer *vb2_buffer; + dma_addr_t address; + + vb2_buffer = &csi_buffer->v4l2_buffer.vb2_buf; + address = vb2_dma_contig_plane_dma_addr(vb2_buffer, 0); + + sun6i_csi_update_buf_addr(csi_dev, address); } static void sun6i_csi_capture_configure(struct sun6i_csi_device *csi_dev) @@ -108,6 +113,119 @@ static void sun6i_csi_capture_configure(struct sun6i_csi_device *csi_dev) sun6i_csi_update_config(csi_dev, &config); } +/* State */ + +static void sun6i_csi_capture_state_cleanup(struct sun6i_csi_device *csi_dev, + bool error) +{ + struct sun6i_csi_capture_state *state = &csi_dev->capture.state; + struct sun6i_csi_buffer **csi_buffer_states[] = { + &state->pending, &state->current, &state->complete, + }; + struct sun6i_csi_buffer *csi_buffer; + struct vb2_buffer *vb2_buffer; + unsigned long flags; + unsigned int i; + + spin_lock_irqsave(&state->lock, flags); + + for (i = 0; i < ARRAY_SIZE(csi_buffer_states); i++) { + csi_buffer = *csi_buffer_states[i]; + if (!csi_buffer) + continue; + + vb2_buffer = &csi_buffer->v4l2_buffer.vb2_buf; + vb2_buffer_done(vb2_buffer, error ? VB2_BUF_STATE_ERROR : + VB2_BUF_STATE_QUEUED); + + *csi_buffer_states[i] = NULL; + } + + list_for_each_entry(csi_buffer, &state->queue, list) { + vb2_buffer = &csi_buffer->v4l2_buffer.vb2_buf; + vb2_buffer_done(vb2_buffer, error ? VB2_BUF_STATE_ERROR : + VB2_BUF_STATE_QUEUED); + } + + INIT_LIST_HEAD(&state->queue); + + spin_unlock_irqrestore(&state->lock, flags); +} + +static void sun6i_csi_capture_state_update(struct sun6i_csi_device *csi_dev) +{ + struct sun6i_csi_capture_state *state = &csi_dev->capture.state; + struct sun6i_csi_buffer *csi_buffer; + unsigned long flags; + + spin_lock_irqsave(&state->lock, flags); + + if (list_empty(&state->queue)) + goto complete; + + if (state->pending) + goto complete; + + csi_buffer = list_first_entry(&state->queue, struct sun6i_csi_buffer, + list); + + sun6i_csi_capture_buffer_configure(csi_dev, csi_buffer); + + list_del(&csi_buffer->list); + + state->pending = csi_buffer; + +complete: + spin_unlock_irqrestore(&state->lock, flags); +} + +static void sun6i_csi_capture_state_complete(struct sun6i_csi_device *csi_dev) +{ + struct sun6i_csi_capture_state *state = &csi_dev->capture.state; + unsigned long flags; + + spin_lock_irqsave(&state->lock, flags); + + if (!state->pending) + goto complete; + + state->complete = state->current; + state->current = state->pending; + state->pending = NULL; + + if (state->complete) { + struct sun6i_csi_buffer *csi_buffer = state->complete; + struct vb2_buffer *vb2_buffer = + &csi_buffer->v4l2_buffer.vb2_buf; + + vb2_buffer->timestamp = ktime_get_ns(); + csi_buffer->v4l2_buffer.sequence = state->sequence; + + vb2_buffer_done(vb2_buffer, VB2_BUF_STATE_DONE); + + state->complete = NULL; + } + +complete: + spin_unlock_irqrestore(&state->lock, flags); +} + +void sun6i_csi_capture_frame_done(struct sun6i_csi_device *csi_dev) +{ + struct sun6i_csi_capture_state *state = &csi_dev->capture.state; + unsigned long flags; + + spin_lock_irqsave(&state->lock, flags); + state->sequence++; + spin_unlock_irqrestore(&state->lock, flags); +} + +void sun6i_csi_capture_sync(struct sun6i_csi_device *csi_dev) +{ + sun6i_csi_capture_state_complete(csi_dev); + sun6i_csi_capture_state_update(csi_dev); +} + /* Queue */ static int sun6i_csi_capture_queue_setup(struct vb2_queue *queue, @@ -117,8 +235,7 @@ static int sun6i_csi_capture_queue_setup(struct vb2_queue *queue, struct device *alloc_devs[]) { struct sun6i_csi_device *csi_dev = vb2_get_drv_priv(queue); - struct sun6i_csi_capture *capture = &csi_dev->capture; - unsigned int size = capture->format.fmt.pix.sizeimage; + unsigned int size = csi_dev->capture.format.fmt.pix.sizeimage; if (*planes_count) return sizes[0] < size ? -EINVAL : 0; @@ -135,8 +252,6 @@ static int sun6i_csi_capture_buffer_prepare(struct vb2_buffer *buffer) struct sun6i_csi_capture *capture = &csi_dev->capture; struct v4l2_device *v4l2_dev = &csi_dev->v4l2.v4l2_dev; struct vb2_v4l2_buffer *v4l2_buffer = to_vb2_v4l2_buffer(buffer); - struct sun6i_csi_buffer *csi_buffer = - container_of(v4l2_buffer, struct sun6i_csi_buffer, v4l2_buffer); unsigned long size = capture->format.fmt.pix.sizeimage; if (vb2_plane_size(buffer, 0) < size) { @@ -147,7 +262,6 @@ static int sun6i_csi_capture_buffer_prepare(struct vb2_buffer *buffer) vb2_set_plane_payload(buffer, 0, size); - csi_buffer->dma_addr = vb2_dma_contig_plane_dma_addr(buffer, 0); v4l2_buffer->field = capture->format.fmt.pix.field; return 0; @@ -156,16 +270,15 @@ static int sun6i_csi_capture_buffer_prepare(struct vb2_buffer *buffer) static void sun6i_csi_capture_buffer_queue(struct vb2_buffer *buffer) { struct sun6i_csi_device *csi_dev = vb2_get_drv_priv(buffer->vb2_queue); - struct sun6i_csi_capture *capture = &csi_dev->capture; + struct sun6i_csi_capture_state *state = &csi_dev->capture.state; struct vb2_v4l2_buffer *v4l2_buffer = to_vb2_v4l2_buffer(buffer); struct sun6i_csi_buffer *csi_buffer = container_of(v4l2_buffer, struct sun6i_csi_buffer, v4l2_buffer); unsigned long flags; - spin_lock_irqsave(&capture->dma_queue_lock, flags); - csi_buffer->queued_to_csi = false; - list_add_tail(&csi_buffer->list, &capture->dma_queue); - spin_unlock_irqrestore(&capture->dma_queue_lock, flags); + spin_lock_irqsave(&state->lock, flags); + list_add_tail(&csi_buffer->list, &state->queue); + spin_unlock_irqrestore(&state->lock, flags); } static int sun6i_csi_capture_start_streaming(struct vb2_queue *queue, @@ -173,18 +286,16 @@ static int sun6i_csi_capture_start_streaming(struct vb2_queue *queue, { struct sun6i_csi_device *csi_dev = vb2_get_drv_priv(queue); struct sun6i_csi_capture *capture = &csi_dev->capture; + struct sun6i_csi_capture_state *state = &capture->state; struct video_device *video_dev = &capture->video_dev; - struct sun6i_csi_buffer *buf; - struct sun6i_csi_buffer *next_buf; struct v4l2_subdev *subdev; - unsigned long flags; int ret; - capture->sequence = 0; + state->sequence = 0; ret = media_pipeline_start(&video_dev->entity, &video_dev->pipe); if (ret < 0) - goto error_dma_queue_flush; + goto error_state; if (capture->mbus_code == 0) { ret = -EINVAL; @@ -197,37 +308,17 @@ static int sun6i_csi_capture_start_streaming(struct vb2_queue *queue, goto error_media_pipeline; } + /* Configure */ + sun6i_csi_capture_configure(csi_dev); - spin_lock_irqsave(&capture->dma_queue_lock, flags); + /* State Update */ - buf = list_first_entry(&capture->dma_queue, - struct sun6i_csi_buffer, list); - sun6i_csi_capture_buffer_configure(csi_dev, buf); + sun6i_csi_capture_state_update(csi_dev); - sun6i_csi_set_stream(csi_dev, true); + /* Enable */ - /* - * CSI will lookup the next dma buffer for next frame before the - * the current frame done IRQ triggered. This is not documented - * but reported by Ondřej Jirman. - * The BSP code has workaround for this too. It skip to mark the - * first buffer as frame done for VB2 and pass the second buffer - * to CSI in the first frame done ISR call. Then in second frame - * done ISR call, it mark the first buffer as frame done for VB2 - * and pass the third buffer to CSI. And so on. The bad thing is - * that the first buffer will be written twice and the first frame - * is dropped even the queued buffer is sufficient. - * So, I make some improvement here. Pass the next buffer to CSI - * just follow starting the CSI. In this case, the first frame - * will be stored in first buffer, second frame in second buffer. - * This method is used to avoid dropping the first frame, it - * would also drop frame when lacking of queued buffer. - */ - next_buf = list_next_entry(buf, list); - sun6i_csi_capture_buffer_configure(csi_dev, next_buf); - - spin_unlock_irqrestore(&capture->dma_queue_lock, flags); + sun6i_csi_set_stream(csi_dev, true); ret = v4l2_subdev_call(subdev, video, s_stream, 1); if (ret && ret != -ENOIOCTLCMD) @@ -241,13 +332,8 @@ static int sun6i_csi_capture_start_streaming(struct vb2_queue *queue, error_media_pipeline: media_pipeline_stop(&video_dev->entity); -error_dma_queue_flush: - spin_lock_irqsave(&capture->dma_queue_lock, flags); - list_for_each_entry(buf, &capture->dma_queue, list) - vb2_buffer_done(&buf->v4l2_buffer.vb2_buf, - VB2_BUF_STATE_QUEUED); - INIT_LIST_HEAD(&capture->dma_queue); - spin_unlock_irqrestore(&capture->dma_queue_lock, flags); +error_state: + sun6i_csi_capture_state_cleanup(csi_dev, false); return ret; } @@ -257,8 +343,6 @@ static void sun6i_csi_capture_stop_streaming(struct vb2_queue *queue) struct sun6i_csi_device *csi_dev = vb2_get_drv_priv(queue); struct sun6i_csi_capture *capture = &csi_dev->capture; struct v4l2_subdev *subdev; - unsigned long flags; - struct sun6i_csi_buffer *buf; subdev = sun6i_csi_capture_remote_subdev(capture, NULL); if (subdev) @@ -268,59 +352,7 @@ static void sun6i_csi_capture_stop_streaming(struct vb2_queue *queue) media_pipeline_stop(&capture->video_dev.entity); - /* Release all active buffers */ - spin_lock_irqsave(&capture->dma_queue_lock, flags); - list_for_each_entry(buf, &capture->dma_queue, list) - vb2_buffer_done(&buf->v4l2_buffer.vb2_buf, VB2_BUF_STATE_ERROR); - INIT_LIST_HEAD(&capture->dma_queue); - spin_unlock_irqrestore(&capture->dma_queue_lock, flags); -} - -void sun6i_csi_capture_frame_done(struct sun6i_csi_device *csi_dev) -{ - struct sun6i_csi_capture *capture = &csi_dev->capture; - struct sun6i_csi_buffer *buf; - struct sun6i_csi_buffer *next_buf; - struct vb2_v4l2_buffer *v4l2_buffer; - - spin_lock(&capture->dma_queue_lock); - - buf = list_first_entry(&capture->dma_queue, - struct sun6i_csi_buffer, list); - if (list_is_last(&buf->list, &capture->dma_queue)) { - dev_dbg(csi_dev->dev, "Frame dropped!\n"); - goto complete; - } - - next_buf = list_next_entry(buf, list); - /* If a new buffer (#next_buf) had not been queued to CSI, the old - * buffer (#buf) is still holding by CSI for storing the next - * frame. So, we queue a new buffer (#next_buf) to CSI then wait - * for next ISR call. - */ - if (!next_buf->queued_to_csi) { - sun6i_csi_capture_buffer_configure(csi_dev, next_buf); - dev_dbg(csi_dev->dev, "Frame dropped!\n"); - goto complete; - } - - list_del(&buf->list); - v4l2_buffer = &buf->v4l2_buffer; - v4l2_buffer->vb2_buf.timestamp = ktime_get_ns(); - v4l2_buffer->sequence = capture->sequence; - vb2_buffer_done(&v4l2_buffer->vb2_buf, VB2_BUF_STATE_DONE); - - /* Prepare buffer for next frame but one. */ - if (!list_is_last(&next_buf->list, &capture->dma_queue)) { - next_buf = list_next_entry(next_buf, list); - sun6i_csi_capture_buffer_configure(csi_dev, next_buf); - } else { - dev_dbg(csi_dev->dev, "Next frame will be dropped!\n"); - } - -complete: - capture->sequence++; - spin_unlock(&capture->dma_queue_lock); + sun6i_csi_capture_state_cleanup(csi_dev, true); } static const struct vb2_ops sun6i_csi_capture_queue_ops = { @@ -639,6 +671,7 @@ static const struct media_entity_operations sun6i_csi_capture_media_ops = { int sun6i_csi_capture_setup(struct sun6i_csi_device *csi_dev) { struct sun6i_csi_capture *capture = &csi_dev->capture; + struct sun6i_csi_capture_state *state = &capture->state; struct v4l2_device *v4l2_dev = &csi_dev->v4l2.v4l2_dev; struct v4l2_subdev *bridge_subdev = &csi_dev->bridge.subdev; struct video_device *video_dev = &capture->video_dev; @@ -648,6 +681,11 @@ int sun6i_csi_capture_setup(struct sun6i_csi_device *csi_dev) struct v4l2_pix_format *pix_format = &format.fmt.pix; int ret; + /* State */ + + INIT_LIST_HEAD(&state->queue); + spin_lock_init(&state->lock); + /* Media Entity */ video_dev->entity.ops = &sun6i_csi_capture_media_ops; @@ -660,13 +698,6 @@ int sun6i_csi_capture_setup(struct sun6i_csi_device *csi_dev) if (ret < 0) return ret; - /* DMA queue */ - - INIT_LIST_HEAD(&capture->dma_queue); - spin_lock_init(&capture->dma_queue_lock); - - capture->sequence = 0; - /* Queue */ mutex_init(&capture->lock); @@ -676,14 +707,12 @@ int sun6i_csi_capture_setup(struct sun6i_csi_device *csi_dev) queue->buf_struct_size = sizeof(struct sun6i_csi_buffer); queue->ops = &sun6i_csi_capture_queue_ops; queue->mem_ops = &vb2_dma_contig_memops; + queue->min_buffers_needed = 2; queue->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; queue->lock = &capture->lock; queue->dev = csi_dev->dev; queue->drv_priv = csi_dev; - /* Make sure non-dropped frame. */ - queue->min_buffers_needed = 3; - ret = vb2_queue_init(queue); if (ret) { v4l2_err(v4l2_dev, "failed to initialize vb2 queue: %d\n", ret); diff --git a/drivers/media/platform/sunxi/sun6i-csi/sun6i_csi_capture.h b/drivers/media/platform/sunxi/sun6i-csi/sun6i_csi_capture.h index 36bba31fcb48..7fa66a2af5ec 100644 --- a/drivers/media/platform/sunxi/sun6i-csi/sun6i_csi_capture.h +++ b/drivers/media/platform/sunxi/sun6i-csi/sun6i_csi_capture.h @@ -13,23 +13,34 @@ struct sun6i_csi_device; +#undef current +struct sun6i_csi_capture_state { + struct list_head queue; + spinlock_t lock; /* Queue and buffers lock. */ + + struct sun6i_csi_buffer *pending; + struct sun6i_csi_buffer *current; + struct sun6i_csi_buffer *complete; + + unsigned int sequence; +}; + struct sun6i_csi_capture { + struct sun6i_csi_capture_state state; + struct video_device video_dev; struct vb2_queue queue; struct mutex lock; /* Queue lock. */ struct media_pad pad; - struct list_head dma_queue; - spinlock_t dma_queue_lock; /* DMA queue lock. */ - struct v4l2_format format; u32 mbus_code; - unsigned int sequence; }; +void sun6i_csi_capture_sync(struct sun6i_csi_device *csi_dev); +void sun6i_csi_capture_frame_done(struct sun6i_csi_device *csi_dev); + int sun6i_csi_capture_setup(struct sun6i_csi_device *csi_dev); void sun6i_csi_capture_cleanup(struct sun6i_csi_device *csi_dev); -void sun6i_csi_capture_frame_done(struct sun6i_csi_device *csi_dev); - #endif /* __SUN6I_CAPTURE_H__ */ -- 2.35.2 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 7DF8EC433EF for ; Fri, 15 Apr 2022 15:43:19 +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: Message-Id:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=9ZPxvMqEzU/lVwxXBWInNCe3REOV7ZHKKxlNeejMiJ0=; b=jN3JzrROyNUM/6 Ksi/3XXdR8CE8+0KNu/G12fU+rqmZ2B6Aod6CG4BYvbAgXOHsqwyDXr71Wq36Nhw5GaYibDtw2FoI QZcOoLtFtL/D4P6h3Z9D4MrVCm3qELuYGpaXyAN3C8PhPNUK8tSvFwkqjTSzbtGUk8fyq7yFXGpNs ezOnF3q/LHVfZMRzLTQ2Gb+FVHHz4crsvvxoGCw91xc9DCjmgdmZPsevaWXqz/gV26RWX5TscMDnV kHNl3p6jHVmd1uoUz//7Q/rhDCcxQr1zX3uyHO2ecBK7SnHkdj5yhzaj1GO3EKRZpqBoQI6BApVhp 3cMIv6UJqZiag3BZlwqw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nfO52-00AdYx-6c; Fri, 15 Apr 2022 15:41:52 +0000 Received: from relay4-d.mail.gandi.net ([217.70.183.196]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1nfNsH-00AXOG-Tf for linux-arm-kernel@lists.infradead.org; Fri, 15 Apr 2022 15:28:53 +0000 Received: (Authenticated sender: paul.kocialkowski@bootlin.com) by mail.gandi.net (Postfix) with ESMTPSA id 6CBC2E0013; Fri, 15 Apr 2022 15:28:39 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1650036520; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=jUjQaMo0gxDEGeQugoELE5k8zPMDdRJCPc5uVTwkmzg=; b=ahh+89EkZKgbAQctLoyxsu4eT/h/O6iwTyfCxCKLjgaxl5EbkZmqrgQfiswbT0AXXukP3x XDOfLIDr3DiEZHs0GP6uQi/wJxe/NrjIHyQyDiftX6davwszyqF4X6hRy0E7iQroVni5tT sBGgmty+VoX4cnfJn1bTSloRmy0R3Dni+FKd1ONEX0BS3S8/H49ExCkNSw+lO2WrKu2XQr NmAuHRwHCfIkBxpHxdcJ13O4RprXTgyW7AydKN5bwsPHAj8oi0zFAoTX351CXxZS8L2PBx t2oHosmakPLsPm3WKHYKjpLVOtG0FfPuNaLdfaHZxP1XVezTbem17O/b5PGtYQ== From: Paul Kocialkowski To: linux-kernel@vger.kernel.org, linux-media@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sunxi@lists.linux.dev Cc: Yong Deng , Paul Kocialkowski , Mauro Carvalho Chehab , Chen-Yu Tsai , Jernej Skrabec , Samuel Holland , Laurent Pinchart , Maxime Ripard , Thomas Petazzoni Subject: [PATCH v4 18/45] media: sun6i-csi: Add capture state using vsync for page flip Date: Fri, 15 Apr 2022 17:27:44 +0200 Message-Id: <20220415152811.636419-19-paul.kocialkowski@bootlin.com> X-Mailer: git-send-email 2.35.2 In-Reply-To: <20220415152811.636419-1-paul.kocialkowski@bootlin.com> References: <20220415152811.636419-1-paul.kocialkowski@bootlin.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220415_082842_340557_D69DA134 X-CRM114-Status: GOOD ( 33.97 ) 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 VGhlIGN1cnJlbnQgaW1wbGVtZW50YXRpb24gcmVxdWlyZXMgdXAgdG8gMyBidWZmZXJzIHRvIHBy b3Blcmx5CmltcGxlbWVudCBwYWdlIGZsaXBwaW5nIHdpdGhvdXQgbG9zaW5nIGZyYW1lczogb25l IGlzIGNvbmZpZ3VyZWQKYmVmb3JlIHRoZSB2aWRlbyBzdHJlYW0gaXMgc3RhcnRlZCwgb25lIGp1 c3QgYWZ0ZXIgdGhhdCBhbmQgcGFnZQpmbGlwcGluZyBpcyBzeW5jaHJvbml6ZWQgdG8gdGhlIGZy YW1lIGRvbmUgaW50ZXJydXB0LiBUaGUgY29tbWVudCBpbgp0aGUgY29kZSBtZW50aW9ucyB0aGF0 ICJDU0kgd2lsbCBsb29rdXAgdGhlIG5leHQgZG1hIGJ1ZmZlciBmb3IgbmV4dApmcmFtZSBiZWZv cmUgdGhlIGN1cnJlbnQgZnJhbWUgZG9uZSBJUlEgdHJpZ2dlcmVkIi4KCkJhc2VkIG9uIG9ic2Vy dmF0aW9ucyBvZiB0aGUgQ1NJIHVuaXQgYmVoYXZpb3IsIGl0IHNlZW1zIHRoYXQgdGhlCmJ1ZmZl ciBETUEgYWRkcmVzcyBpcyBzYW1wbGVkIHdoZW4gdGhlIGZyYW1lIHNjYW4gYmVnaW5zIChpbiBh ZGRpdGlvbgp0byBzdGFydGluZyB0aGUgc3RyZWFtKSwgd2hpY2ggY29ycmVzcG9uZHMgdG8gdGhl IHZibGFuayBpbnRlcnJ1cHQKdGhhdCBoaXRzIGp1c3QgYmVmb3JlIHRoZSBmcmFtZS1kb25lIGlu dGVycnVwdCBvZiB0aGUgcHJldmlvdXMgZnJhbWUuCgpBcyBhIHJlc3VsdCwgdGhlIGFkZHJlc3Mg Y29uZmlndXJlZCBhdCB0aGUgZnJhbWUgZG9uZSBpbnRlcnJ1cHQgaXMgbm90CmFjdHVhbGx5IHVz ZWQgZm9yIHRoZSBuZXh0IGZyYW1lIGJ1dCBmb3IgdGhlIG9uZSBhZnRlciB0aGF0LgoKVGhpcyBw cm9wb3NhbCBjaGFuZ2VzIHRoZSBwYWdlIGZsaXBwaW5nIHN5bmMgcG9pbnQgdG8gdGhlIHZzeW5j CmludGVycnVwdCwgd2hpY2ggYWxsb3dzIHRoZSBETUEgYWRkcmVzcyB0byBiZSBzYW1wbGVkIGZv ciB0aGUgbmV4dApmcmFtZSBpbnN0ZWFkIGFuZCBhbGxvd3Mgb3BlcmF0aW5nIHdpdGggb25seSB0 d28gYnVmZmVycy4KCkluIGFkZGl0aW9uIHRvIHRoZSBjaGFuZ2UgaW4gdGhlIHN5bmMgcG9pbnQs IHRoZSBjb2RlIGlzIHJlZmFjdG9yZWQKdG8gaW50cm9kdWNlIGEgbm90aW9uIG9mIHN0YXRlIHRo YXQgY2xhcmlmaWVzIHRyYWNraW5nIG9mIHRoZSBidWZmZXJzCndpdGggdGlkeSBmdW5jdGlvbnMu CgpTaWduZWQtb2ZmLWJ5OiBQYXVsIEtvY2lhbGtvd3NraSA8cGF1bC5rb2NpYWxrb3dza2lAYm9v dGxpbi5jb20+Ci0tLQogLi4uL3BsYXRmb3JtL3N1bnhpL3N1bjZpLWNzaS9zdW42aV9jc2kuYyAg ICAgIHwgICA0ICsKIC4uLi9wbGF0Zm9ybS9zdW54aS9zdW42aS1jc2kvc3VuNmlfY3NpLmggICAg ICB8ICAgMyAtCiAuLi4vc3VueGkvc3VuNmktY3NpL3N1bjZpX2NzaV9jYXB0dXJlLmMgICAgICAg fCAyNTkgKysrKysrKysrKy0tLS0tLS0tCiAuLi4vc3VueGkvc3VuNmktY3NpL3N1bjZpX2NzaV9j YXB0dXJlLmggICAgICAgfCAgMjMgKy0KIDQgZmlsZXMgY2hhbmdlZCwgMTY1IGluc2VydGlvbnMo KyksIDEyNCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRmb3Jt L3N1bnhpL3N1bjZpLWNzaS9zdW42aV9jc2kuYyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc3Vu eGkvc3VuNmktY3NpL3N1bjZpX2NzaS5jCmluZGV4IDYyZjY1ODY3Yzc3MS4uNTY1NmZhZjE1ZDdl IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3N1bnhpL3N1bjZpLWNzaS9zdW42 aV9jc2kuYworKysgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3N1bnhpL3N1bjZpLWNzaS9zdW42 aV9jc2kuYwpAQCAtNTY2LDYgKzU2Niw3IEBAIHZvaWQgc3VuNmlfY3NpX3NldF9zdHJlYW0oc3Ry dWN0IHN1bjZpX2NzaV9kZXZpY2UgKmNzaV9kZXYsIGJvb2wgZW5hYmxlKQogCiAJcmVnbWFwX3dy aXRlKHJlZ21hcCwgQ1NJX0NIX0lOVF9TVEFfUkVHLCAweEZGKTsKIAlyZWdtYXBfd3JpdGUocmVn bWFwLCBDU0lfQ0hfSU5UX0VOX1JFRywKKwkJICAgICBDU0lfQ0hfSU5UX0VOX1ZTX0lOVF9FTiB8 CiAJCSAgICAgQ1NJX0NIX0lOVF9FTl9IQl9PRl9JTlRfRU4gfAogCQkgICAgIENTSV9DSF9JTlRf RU5fRklGTzJfT0ZfSU5UX0VOIHwKIAkJICAgICBDU0lfQ0hfSU5UX0VOX0ZJRk8xX09GX0lOVF9F TiB8CkBAIC02NzksNiArNjgwLDkgQEAgc3RhdGljIGlycXJldHVybl90IHN1bjZpX2NzaV9pbnRl cnJ1cHQoaW50IGlycSwgdm9pZCAqcHJpdmF0ZSkKIAlpZiAoc3RhdHVzICYgQ1NJX0NIX0lOVF9T VEFfRkRfUEQpCiAJCXN1bjZpX2NzaV9jYXB0dXJlX2ZyYW1lX2RvbmUoY3NpX2Rldik7CiAKKwlp ZiAoc3RhdHVzICYgQ1NJX0NIX0lOVF9TVEFfVlNfUEQpCisJCXN1bjZpX2NzaV9jYXB0dXJlX3N5 bmMoY3NpX2Rldik7CisKIAlyZWdtYXBfd3JpdGUocmVnbWFwLCBDU0lfQ0hfSU5UX1NUQV9SRUcs IHN0YXR1cyk7CiAKIAlyZXR1cm4gSVJRX0hBTkRMRUQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21l ZGlhL3BsYXRmb3JtL3N1bnhpL3N1bjZpLWNzaS9zdW42aV9jc2kuaCBiL2RyaXZlcnMvbWVkaWEv cGxhdGZvcm0vc3VueGkvc3VuNmktY3NpL3N1bjZpX2NzaS5oCmluZGV4IDQyMmQ3Yjk5MzlmOS4u ZjAyNjU2ZGJmZDg0IDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3N1bnhpL3N1 bjZpLWNzaS9zdW42aV9jc2kuaAorKysgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3N1bnhpL3N1 bjZpLWNzaS9zdW42aV9jc2kuaApAQCAtMjYsOSArMjYsNiBAQCBlbnVtIHN1bjZpX2NzaV9wb3J0 IHsKIHN0cnVjdCBzdW42aV9jc2lfYnVmZmVyIHsKIAlzdHJ1Y3QgdmIyX3Y0bDJfYnVmZmVyCQl2 NGwyX2J1ZmZlcjsKIAlzdHJ1Y3QgbGlzdF9oZWFkCQlsaXN0OwotCi0JZG1hX2FkZHJfdAkJCWRt YV9hZGRyOwotCWJvb2wJCQkJcXVldWVkX3RvX2NzaTsKIH07CiAKIC8qKgpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zdW54aS9zdW42aS1jc2kvc3VuNmlfY3NpX2NhcHR1cmUu YyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vc3VueGkvc3VuNmktY3NpL3N1bjZpX2NzaV9jYXB0 dXJlLmMKaW5kZXggY2IyOWRkZjZhZjI3Li5lMjI3OTQwY2I2NmUgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvbWVkaWEvcGxhdGZvcm0vc3VueGkvc3VuNmktY3NpL3N1bjZpX2NzaV9jYXB0dXJlLmMKKysr IGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS9zdW54aS9zdW42aS1jc2kvc3VuNmlfY3NpX2NhcHR1 cmUuYwpAQCAtOTAsOCArOTAsMTMgQEAgc3RhdGljIHZvaWQKIHN1bjZpX2NzaV9jYXB0dXJlX2J1 ZmZlcl9jb25maWd1cmUoc3RydWN0IHN1bjZpX2NzaV9kZXZpY2UgKmNzaV9kZXYsCiAJCQkJICAg c3RydWN0IHN1bjZpX2NzaV9idWZmZXIgKmNzaV9idWZmZXIpCiB7Ci0JY3NpX2J1ZmZlci0+cXVl dWVkX3RvX2NzaSA9IHRydWU7Ci0Jc3VuNmlfY3NpX3VwZGF0ZV9idWZfYWRkcihjc2lfZGV2LCBj c2lfYnVmZmVyLT5kbWFfYWRkcik7CisJc3RydWN0IHZiMl9idWZmZXIgKnZiMl9idWZmZXI7CisJ ZG1hX2FkZHJfdCBhZGRyZXNzOworCisJdmIyX2J1ZmZlciA9ICZjc2lfYnVmZmVyLT52NGwyX2J1 ZmZlci52YjJfYnVmOworCWFkZHJlc3MgPSB2YjJfZG1hX2NvbnRpZ19wbGFuZV9kbWFfYWRkcih2 YjJfYnVmZmVyLCAwKTsKKworCXN1bjZpX2NzaV91cGRhdGVfYnVmX2FkZHIoY3NpX2RldiwgYWRk cmVzcyk7CiB9CiAKIHN0YXRpYyB2b2lkIHN1bjZpX2NzaV9jYXB0dXJlX2NvbmZpZ3VyZShzdHJ1 Y3Qgc3VuNmlfY3NpX2RldmljZSAqY3NpX2RldikKQEAgLTEwOCw2ICsxMTMsMTE5IEBAIHN0YXRp YyB2b2lkIHN1bjZpX2NzaV9jYXB0dXJlX2NvbmZpZ3VyZShzdHJ1Y3Qgc3VuNmlfY3NpX2Rldmlj ZSAqY3NpX2RldikKIAlzdW42aV9jc2lfdXBkYXRlX2NvbmZpZyhjc2lfZGV2LCAmY29uZmlnKTsK IH0KIAorLyogU3RhdGUgKi8KKworc3RhdGljIHZvaWQgc3VuNmlfY3NpX2NhcHR1cmVfc3RhdGVf Y2xlYW51cChzdHJ1Y3Qgc3VuNmlfY3NpX2RldmljZSAqY3NpX2RldiwKKwkJCQkJICAgIGJvb2wg ZXJyb3IpCit7CisJc3RydWN0IHN1bjZpX2NzaV9jYXB0dXJlX3N0YXRlICpzdGF0ZSA9ICZjc2lf ZGV2LT5jYXB0dXJlLnN0YXRlOworCXN0cnVjdCBzdW42aV9jc2lfYnVmZmVyICoqY3NpX2J1ZmZl cl9zdGF0ZXNbXSA9IHsKKwkJJnN0YXRlLT5wZW5kaW5nLCAmc3RhdGUtPmN1cnJlbnQsICZzdGF0 ZS0+Y29tcGxldGUsCisJfTsKKwlzdHJ1Y3Qgc3VuNmlfY3NpX2J1ZmZlciAqY3NpX2J1ZmZlcjsK KwlzdHJ1Y3QgdmIyX2J1ZmZlciAqdmIyX2J1ZmZlcjsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOwor CXVuc2lnbmVkIGludCBpOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJnN0YXRlLT5sb2NrLCBmbGFn cyk7CisKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShjc2lfYnVmZmVyX3N0YXRlcyk7IGkr KykgeworCQljc2lfYnVmZmVyID0gKmNzaV9idWZmZXJfc3RhdGVzW2ldOworCQlpZiAoIWNzaV9i dWZmZXIpCisJCQljb250aW51ZTsKKworCQl2YjJfYnVmZmVyID0gJmNzaV9idWZmZXItPnY0bDJf YnVmZmVyLnZiMl9idWY7CisJCXZiMl9idWZmZXJfZG9uZSh2YjJfYnVmZmVyLCBlcnJvciA/IFZC Ml9CVUZfU1RBVEVfRVJST1IgOgorCQkJCVZCMl9CVUZfU1RBVEVfUVVFVUVEKTsKKworCQkqY3Np X2J1ZmZlcl9zdGF0ZXNbaV0gPSBOVUxMOworCX0KKworCWxpc3RfZm9yX2VhY2hfZW50cnkoY3Np X2J1ZmZlciwgJnN0YXRlLT5xdWV1ZSwgbGlzdCkgeworCQl2YjJfYnVmZmVyID0gJmNzaV9idWZm ZXItPnY0bDJfYnVmZmVyLnZiMl9idWY7CisJCXZiMl9idWZmZXJfZG9uZSh2YjJfYnVmZmVyLCBl cnJvciA/IFZCMl9CVUZfU1RBVEVfRVJST1IgOgorCQkJCVZCMl9CVUZfU1RBVEVfUVVFVUVEKTsK Kwl9CisKKwlJTklUX0xJU1RfSEVBRCgmc3RhdGUtPnF1ZXVlKTsKKworCXNwaW5fdW5sb2NrX2ly cXJlc3RvcmUoJnN0YXRlLT5sb2NrLCBmbGFncyk7Cit9CisKK3N0YXRpYyB2b2lkIHN1bjZpX2Nz aV9jYXB0dXJlX3N0YXRlX3VwZGF0ZShzdHJ1Y3Qgc3VuNmlfY3NpX2RldmljZSAqY3NpX2RldikK K3sKKwlzdHJ1Y3Qgc3VuNmlfY3NpX2NhcHR1cmVfc3RhdGUgKnN0YXRlID0gJmNzaV9kZXYtPmNh cHR1cmUuc3RhdGU7CisJc3RydWN0IHN1bjZpX2NzaV9idWZmZXIgKmNzaV9idWZmZXI7CisJdW5z aWduZWQgbG9uZyBmbGFnczsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZzdGF0ZS0+bG9jaywgZmxh Z3MpOworCisJaWYgKGxpc3RfZW1wdHkoJnN0YXRlLT5xdWV1ZSkpCisJCWdvdG8gY29tcGxldGU7 CisKKwlpZiAoc3RhdGUtPnBlbmRpbmcpCisJCWdvdG8gY29tcGxldGU7CisKKwljc2lfYnVmZmVy ID0gbGlzdF9maXJzdF9lbnRyeSgmc3RhdGUtPnF1ZXVlLCBzdHJ1Y3Qgc3VuNmlfY3NpX2J1ZmZl ciwKKwkJCQkgICAgICBsaXN0KTsKKworCXN1bjZpX2NzaV9jYXB0dXJlX2J1ZmZlcl9jb25maWd1 cmUoY3NpX2RldiwgY3NpX2J1ZmZlcik7CisKKwlsaXN0X2RlbCgmY3NpX2J1ZmZlci0+bGlzdCk7 CisKKwlzdGF0ZS0+cGVuZGluZyA9IGNzaV9idWZmZXI7CisKK2NvbXBsZXRlOgorCXNwaW5fdW5s b2NrX2lycXJlc3RvcmUoJnN0YXRlLT5sb2NrLCBmbGFncyk7Cit9CisKK3N0YXRpYyB2b2lkIHN1 bjZpX2NzaV9jYXB0dXJlX3N0YXRlX2NvbXBsZXRlKHN0cnVjdCBzdW42aV9jc2lfZGV2aWNlICpj c2lfZGV2KQoreworCXN0cnVjdCBzdW42aV9jc2lfY2FwdHVyZV9zdGF0ZSAqc3RhdGUgPSAmY3Np X2Rldi0+Y2FwdHVyZS5zdGF0ZTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJc3Bpbl9sb2Nr X2lycXNhdmUoJnN0YXRlLT5sb2NrLCBmbGFncyk7CisKKwlpZiAoIXN0YXRlLT5wZW5kaW5nKQor CQlnb3RvIGNvbXBsZXRlOworCisJc3RhdGUtPmNvbXBsZXRlID0gc3RhdGUtPmN1cnJlbnQ7CisJ c3RhdGUtPmN1cnJlbnQgPSBzdGF0ZS0+cGVuZGluZzsKKwlzdGF0ZS0+cGVuZGluZyA9IE5VTEw7 CisKKwlpZiAoc3RhdGUtPmNvbXBsZXRlKSB7CisJCXN0cnVjdCBzdW42aV9jc2lfYnVmZmVyICpj c2lfYnVmZmVyID0gc3RhdGUtPmNvbXBsZXRlOworCQlzdHJ1Y3QgdmIyX2J1ZmZlciAqdmIyX2J1 ZmZlciA9CisJCQkmY3NpX2J1ZmZlci0+djRsMl9idWZmZXIudmIyX2J1ZjsKKworCQl2YjJfYnVm ZmVyLT50aW1lc3RhbXAgPSBrdGltZV9nZXRfbnMoKTsKKwkJY3NpX2J1ZmZlci0+djRsMl9idWZm ZXIuc2VxdWVuY2UgPSBzdGF0ZS0+c2VxdWVuY2U7CisKKwkJdmIyX2J1ZmZlcl9kb25lKHZiMl9i dWZmZXIsIFZCMl9CVUZfU1RBVEVfRE9ORSk7CisKKwkJc3RhdGUtPmNvbXBsZXRlID0gTlVMTDsK Kwl9CisKK2NvbXBsZXRlOgorCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnN0YXRlLT5sb2NrLCBm bGFncyk7Cit9CisKK3ZvaWQgc3VuNmlfY3NpX2NhcHR1cmVfZnJhbWVfZG9uZShzdHJ1Y3Qgc3Vu NmlfY3NpX2RldmljZSAqY3NpX2RldikKK3sKKwlzdHJ1Y3Qgc3VuNmlfY3NpX2NhcHR1cmVfc3Rh dGUgKnN0YXRlID0gJmNzaV9kZXYtPmNhcHR1cmUuc3RhdGU7CisJdW5zaWduZWQgbG9uZyBmbGFn czsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZzdGF0ZS0+bG9jaywgZmxhZ3MpOworCXN0YXRlLT5z ZXF1ZW5jZSsrOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnN0YXRlLT5sb2NrLCBmbGFncyk7 Cit9CisKK3ZvaWQgc3VuNmlfY3NpX2NhcHR1cmVfc3luYyhzdHJ1Y3Qgc3VuNmlfY3NpX2Rldmlj ZSAqY3NpX2RldikKK3sKKwlzdW42aV9jc2lfY2FwdHVyZV9zdGF0ZV9jb21wbGV0ZShjc2lfZGV2 KTsKKwlzdW42aV9jc2lfY2FwdHVyZV9zdGF0ZV91cGRhdGUoY3NpX2Rldik7Cit9CisKIC8qIFF1 ZXVlICovCiAKIHN0YXRpYyBpbnQgc3VuNmlfY3NpX2NhcHR1cmVfcXVldWVfc2V0dXAoc3RydWN0 IHZiMl9xdWV1ZSAqcXVldWUsCkBAIC0xMTcsOCArMjM1LDcgQEAgc3RhdGljIGludCBzdW42aV9j c2lfY2FwdHVyZV9xdWV1ZV9zZXR1cChzdHJ1Y3QgdmIyX3F1ZXVlICpxdWV1ZSwKIAkJCQkJIHN0 cnVjdCBkZXZpY2UgKmFsbG9jX2RldnNbXSkKIHsKIAlzdHJ1Y3Qgc3VuNmlfY3NpX2RldmljZSAq Y3NpX2RldiA9IHZiMl9nZXRfZHJ2X3ByaXYocXVldWUpOwotCXN0cnVjdCBzdW42aV9jc2lfY2Fw dHVyZSAqY2FwdHVyZSA9ICZjc2lfZGV2LT5jYXB0dXJlOwotCXVuc2lnbmVkIGludCBzaXplID0g Y2FwdHVyZS0+Zm9ybWF0LmZtdC5waXguc2l6ZWltYWdlOworCXVuc2lnbmVkIGludCBzaXplID0g Y3NpX2Rldi0+Y2FwdHVyZS5mb3JtYXQuZm10LnBpeC5zaXplaW1hZ2U7CiAKIAlpZiAoKnBsYW5l c19jb3VudCkKIAkJcmV0dXJuIHNpemVzWzBdIDwgc2l6ZSA/IC1FSU5WQUwgOiAwOwpAQCAtMTM1 LDggKzI1Miw2IEBAIHN0YXRpYyBpbnQgc3VuNmlfY3NpX2NhcHR1cmVfYnVmZmVyX3ByZXBhcmUo c3RydWN0IHZiMl9idWZmZXIgKmJ1ZmZlcikKIAlzdHJ1Y3Qgc3VuNmlfY3NpX2NhcHR1cmUgKmNh cHR1cmUgPSAmY3NpX2Rldi0+Y2FwdHVyZTsKIAlzdHJ1Y3QgdjRsMl9kZXZpY2UgKnY0bDJfZGV2 ID0gJmNzaV9kZXYtPnY0bDIudjRsMl9kZXY7CiAJc3RydWN0IHZiMl92NGwyX2J1ZmZlciAqdjRs Ml9idWZmZXIgPSB0b192YjJfdjRsMl9idWZmZXIoYnVmZmVyKTsKLQlzdHJ1Y3Qgc3VuNmlfY3Np X2J1ZmZlciAqY3NpX2J1ZmZlciA9Ci0JCWNvbnRhaW5lcl9vZih2NGwyX2J1ZmZlciwgc3RydWN0 IHN1bjZpX2NzaV9idWZmZXIsIHY0bDJfYnVmZmVyKTsKIAl1bnNpZ25lZCBsb25nIHNpemUgPSBj YXB0dXJlLT5mb3JtYXQuZm10LnBpeC5zaXplaW1hZ2U7CiAKIAlpZiAodmIyX3BsYW5lX3NpemUo YnVmZmVyLCAwKSA8IHNpemUpIHsKQEAgLTE0Nyw3ICsyNjIsNiBAQCBzdGF0aWMgaW50IHN1bjZp X2NzaV9jYXB0dXJlX2J1ZmZlcl9wcmVwYXJlKHN0cnVjdCB2YjJfYnVmZmVyICpidWZmZXIpCiAK IAl2YjJfc2V0X3BsYW5lX3BheWxvYWQoYnVmZmVyLCAwLCBzaXplKTsKIAotCWNzaV9idWZmZXIt PmRtYV9hZGRyID0gdmIyX2RtYV9jb250aWdfcGxhbmVfZG1hX2FkZHIoYnVmZmVyLCAwKTsKIAl2 NGwyX2J1ZmZlci0+ZmllbGQgPSBjYXB0dXJlLT5mb3JtYXQuZm10LnBpeC5maWVsZDsKIAogCXJl dHVybiAwOwpAQCAtMTU2LDE2ICsyNzAsMTUgQEAgc3RhdGljIGludCBzdW42aV9jc2lfY2FwdHVy ZV9idWZmZXJfcHJlcGFyZShzdHJ1Y3QgdmIyX2J1ZmZlciAqYnVmZmVyKQogc3RhdGljIHZvaWQg c3VuNmlfY3NpX2NhcHR1cmVfYnVmZmVyX3F1ZXVlKHN0cnVjdCB2YjJfYnVmZmVyICpidWZmZXIp CiB7CiAJc3RydWN0IHN1bjZpX2NzaV9kZXZpY2UgKmNzaV9kZXYgPSB2YjJfZ2V0X2Rydl9wcml2 KGJ1ZmZlci0+dmIyX3F1ZXVlKTsKLQlzdHJ1Y3Qgc3VuNmlfY3NpX2NhcHR1cmUgKmNhcHR1cmUg PSAmY3NpX2Rldi0+Y2FwdHVyZTsKKwlzdHJ1Y3Qgc3VuNmlfY3NpX2NhcHR1cmVfc3RhdGUgKnN0 YXRlID0gJmNzaV9kZXYtPmNhcHR1cmUuc3RhdGU7CiAJc3RydWN0IHZiMl92NGwyX2J1ZmZlciAq djRsMl9idWZmZXIgPSB0b192YjJfdjRsMl9idWZmZXIoYnVmZmVyKTsKIAlzdHJ1Y3Qgc3VuNmlf Y3NpX2J1ZmZlciAqY3NpX2J1ZmZlciA9CiAJCWNvbnRhaW5lcl9vZih2NGwyX2J1ZmZlciwgc3Ry dWN0IHN1bjZpX2NzaV9idWZmZXIsIHY0bDJfYnVmZmVyKTsKIAl1bnNpZ25lZCBsb25nIGZsYWdz OwogCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJmNhcHR1cmUtPmRtYV9xdWV1ZV9sb2NrLCBmbGFncyk7 Ci0JY3NpX2J1ZmZlci0+cXVldWVkX3RvX2NzaSA9IGZhbHNlOwotCWxpc3RfYWRkX3RhaWwoJmNz aV9idWZmZXItPmxpc3QsICZjYXB0dXJlLT5kbWFfcXVldWUpOwotCXNwaW5fdW5sb2NrX2lycXJl c3RvcmUoJmNhcHR1cmUtPmRtYV9xdWV1ZV9sb2NrLCBmbGFncyk7CisJc3Bpbl9sb2NrX2lycXNh dmUoJnN0YXRlLT5sb2NrLCBmbGFncyk7CisJbGlzdF9hZGRfdGFpbCgmY3NpX2J1ZmZlci0+bGlz dCwgJnN0YXRlLT5xdWV1ZSk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmc3RhdGUtPmxvY2ss IGZsYWdzKTsKIH0KIAogc3RhdGljIGludCBzdW42aV9jc2lfY2FwdHVyZV9zdGFydF9zdHJlYW1p bmcoc3RydWN0IHZiMl9xdWV1ZSAqcXVldWUsCkBAIC0xNzMsMTggKzI4NiwxNiBAQCBzdGF0aWMg aW50IHN1bjZpX2NzaV9jYXB0dXJlX3N0YXJ0X3N0cmVhbWluZyhzdHJ1Y3QgdmIyX3F1ZXVlICpx dWV1ZSwKIHsKIAlzdHJ1Y3Qgc3VuNmlfY3NpX2RldmljZSAqY3NpX2RldiA9IHZiMl9nZXRfZHJ2 X3ByaXYocXVldWUpOwogCXN0cnVjdCBzdW42aV9jc2lfY2FwdHVyZSAqY2FwdHVyZSA9ICZjc2lf ZGV2LT5jYXB0dXJlOworCXN0cnVjdCBzdW42aV9jc2lfY2FwdHVyZV9zdGF0ZSAqc3RhdGUgPSAm Y2FwdHVyZS0+c3RhdGU7CiAJc3RydWN0IHZpZGVvX2RldmljZSAqdmlkZW9fZGV2ID0gJmNhcHR1 cmUtPnZpZGVvX2RldjsKLQlzdHJ1Y3Qgc3VuNmlfY3NpX2J1ZmZlciAqYnVmOwotCXN0cnVjdCBz dW42aV9jc2lfYnVmZmVyICpuZXh0X2J1ZjsKIAlzdHJ1Y3QgdjRsMl9zdWJkZXYgKnN1YmRldjsK LQl1bnNpZ25lZCBsb25nIGZsYWdzOwogCWludCByZXQ7CiAKLQljYXB0dXJlLT5zZXF1ZW5jZSA9 IDA7CisJc3RhdGUtPnNlcXVlbmNlID0gMDsKIAogCXJldCA9IG1lZGlhX3BpcGVsaW5lX3N0YXJ0 KCZ2aWRlb19kZXYtPmVudGl0eSwgJnZpZGVvX2Rldi0+cGlwZSk7CiAJaWYgKHJldCA8IDApCi0J CWdvdG8gZXJyb3JfZG1hX3F1ZXVlX2ZsdXNoOworCQlnb3RvIGVycm9yX3N0YXRlOwogCiAJaWYg KGNhcHR1cmUtPm1idXNfY29kZSA9PSAwKSB7CiAJCXJldCA9IC1FSU5WQUw7CkBAIC0xOTcsMzcg KzMwOCwxNyBAQCBzdGF0aWMgaW50IHN1bjZpX2NzaV9jYXB0dXJlX3N0YXJ0X3N0cmVhbWluZyhz dHJ1Y3QgdmIyX3F1ZXVlICpxdWV1ZSwKIAkJZ290byBlcnJvcl9tZWRpYV9waXBlbGluZTsKIAl9 CiAKKwkvKiBDb25maWd1cmUgKi8KKwogCXN1bjZpX2NzaV9jYXB0dXJlX2NvbmZpZ3VyZShjc2lf ZGV2KTsKIAotCXNwaW5fbG9ja19pcnFzYXZlKCZjYXB0dXJlLT5kbWFfcXVldWVfbG9jaywgZmxh Z3MpOworCS8qIFN0YXRlIFVwZGF0ZSAqLwogCi0JYnVmID0gbGlzdF9maXJzdF9lbnRyeSgmY2Fw dHVyZS0+ZG1hX3F1ZXVlLAotCQkJICAgICAgIHN0cnVjdCBzdW42aV9jc2lfYnVmZmVyLCBsaXN0 KTsKLQlzdW42aV9jc2lfY2FwdHVyZV9idWZmZXJfY29uZmlndXJlKGNzaV9kZXYsIGJ1Zik7CisJ c3VuNmlfY3NpX2NhcHR1cmVfc3RhdGVfdXBkYXRlKGNzaV9kZXYpOwogCi0Jc3VuNmlfY3NpX3Nl dF9zdHJlYW0oY3NpX2RldiwgdHJ1ZSk7CisJLyogRW5hYmxlICovCiAKLQkvKgotCSAqIENTSSB3 aWxsIGxvb2t1cCB0aGUgbmV4dCBkbWEgYnVmZmVyIGZvciBuZXh0IGZyYW1lIGJlZm9yZSB0aGUK LQkgKiB0aGUgY3VycmVudCBmcmFtZSBkb25lIElSUSB0cmlnZ2VyZWQuIFRoaXMgaXMgbm90IGRv Y3VtZW50ZWQKLQkgKiBidXQgcmVwb3J0ZWQgYnkgT25kxZllaiBKaXJtYW4uCi0JICogVGhlIEJT UCBjb2RlIGhhcyB3b3JrYXJvdW5kIGZvciB0aGlzIHRvby4gSXQgc2tpcCB0byBtYXJrIHRoZQot CSAqIGZpcnN0IGJ1ZmZlciBhcyBmcmFtZSBkb25lIGZvciBWQjIgYW5kIHBhc3MgdGhlIHNlY29u ZCBidWZmZXIKLQkgKiB0byBDU0kgaW4gdGhlIGZpcnN0IGZyYW1lIGRvbmUgSVNSIGNhbGwuIFRo ZW4gaW4gc2Vjb25kIGZyYW1lCi0JICogZG9uZSBJU1IgY2FsbCwgaXQgbWFyayB0aGUgZmlyc3Qg YnVmZmVyIGFzIGZyYW1lIGRvbmUgZm9yIFZCMgotCSAqIGFuZCBwYXNzIHRoZSB0aGlyZCBidWZm ZXIgdG8gQ1NJLiBBbmQgc28gb24uIFRoZSBiYWQgdGhpbmcgaXMKLQkgKiB0aGF0IHRoZSBmaXJz dCBidWZmZXIgd2lsbCBiZSB3cml0dGVuIHR3aWNlIGFuZCB0aGUgZmlyc3QgZnJhbWUKLQkgKiBp cyBkcm9wcGVkIGV2ZW4gdGhlIHF1ZXVlZCBidWZmZXIgaXMgc3VmZmljaWVudC4KLQkgKiBTbywg SSBtYWtlIHNvbWUgaW1wcm92ZW1lbnQgaGVyZS4gUGFzcyB0aGUgbmV4dCBidWZmZXIgdG8gQ1NJ Ci0JICoganVzdCBmb2xsb3cgc3RhcnRpbmcgdGhlIENTSS4gSW4gdGhpcyBjYXNlLCB0aGUgZmly c3QgZnJhbWUKLQkgKiB3aWxsIGJlIHN0b3JlZCBpbiBmaXJzdCBidWZmZXIsIHNlY29uZCBmcmFt ZSBpbiBzZWNvbmQgYnVmZmVyLgotCSAqIFRoaXMgbWV0aG9kIGlzIHVzZWQgdG8gYXZvaWQgZHJv cHBpbmcgdGhlIGZpcnN0IGZyYW1lLCBpdAotCSAqIHdvdWxkIGFsc28gZHJvcCBmcmFtZSB3aGVu IGxhY2tpbmcgb2YgcXVldWVkIGJ1ZmZlci4KLQkgKi8KLQluZXh0X2J1ZiA9IGxpc3RfbmV4dF9l bnRyeShidWYsIGxpc3QpOwotCXN1bjZpX2NzaV9jYXB0dXJlX2J1ZmZlcl9jb25maWd1cmUoY3Np X2RldiwgbmV4dF9idWYpOwotCi0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY2FwdHVyZS0+ZG1h X3F1ZXVlX2xvY2ssIGZsYWdzKTsKKwlzdW42aV9jc2lfc2V0X3N0cmVhbShjc2lfZGV2LCB0cnVl KTsKIAogCXJldCA9IHY0bDJfc3ViZGV2X2NhbGwoc3ViZGV2LCB2aWRlbywgc19zdHJlYW0sIDEp OwogCWlmIChyZXQgJiYgcmV0ICE9IC1FTk9JT0NUTENNRCkKQEAgLTI0MSwxMyArMzMyLDggQEAg c3RhdGljIGludCBzdW42aV9jc2lfY2FwdHVyZV9zdGFydF9zdHJlYW1pbmcoc3RydWN0IHZiMl9x dWV1ZSAqcXVldWUsCiBlcnJvcl9tZWRpYV9waXBlbGluZToKIAltZWRpYV9waXBlbGluZV9zdG9w KCZ2aWRlb19kZXYtPmVudGl0eSk7CiAKLWVycm9yX2RtYV9xdWV1ZV9mbHVzaDoKLQlzcGluX2xv Y2tfaXJxc2F2ZSgmY2FwdHVyZS0+ZG1hX3F1ZXVlX2xvY2ssIGZsYWdzKTsKLQlsaXN0X2Zvcl9l YWNoX2VudHJ5KGJ1ZiwgJmNhcHR1cmUtPmRtYV9xdWV1ZSwgbGlzdCkKLQkJdmIyX2J1ZmZlcl9k b25lKCZidWYtPnY0bDJfYnVmZmVyLnZiMl9idWYsCi0JCQkJVkIyX0JVRl9TVEFURV9RVUVVRUQp OwotCUlOSVRfTElTVF9IRUFEKCZjYXB0dXJlLT5kbWFfcXVldWUpOwotCXNwaW5fdW5sb2NrX2ly cXJlc3RvcmUoJmNhcHR1cmUtPmRtYV9xdWV1ZV9sb2NrLCBmbGFncyk7CitlcnJvcl9zdGF0ZToK KwlzdW42aV9jc2lfY2FwdHVyZV9zdGF0ZV9jbGVhbnVwKGNzaV9kZXYsIGZhbHNlKTsKIAogCXJl dHVybiByZXQ7CiB9CkBAIC0yNTcsOCArMzQzLDYgQEAgc3RhdGljIHZvaWQgc3VuNmlfY3NpX2Nh cHR1cmVfc3RvcF9zdHJlYW1pbmcoc3RydWN0IHZiMl9xdWV1ZSAqcXVldWUpCiAJc3RydWN0IHN1 bjZpX2NzaV9kZXZpY2UgKmNzaV9kZXYgPSB2YjJfZ2V0X2Rydl9wcml2KHF1ZXVlKTsKIAlzdHJ1 Y3Qgc3VuNmlfY3NpX2NhcHR1cmUgKmNhcHR1cmUgPSAmY3NpX2Rldi0+Y2FwdHVyZTsKIAlzdHJ1 Y3QgdjRsMl9zdWJkZXYgKnN1YmRldjsKLQl1bnNpZ25lZCBsb25nIGZsYWdzOwotCXN0cnVjdCBz dW42aV9jc2lfYnVmZmVyICpidWY7CiAKIAlzdWJkZXYgPSBzdW42aV9jc2lfY2FwdHVyZV9yZW1v dGVfc3ViZGV2KGNhcHR1cmUsIE5VTEwpOwogCWlmIChzdWJkZXYpCkBAIC0yNjgsNTkgKzM1Miw3 IEBAIHN0YXRpYyB2b2lkIHN1bjZpX2NzaV9jYXB0dXJlX3N0b3Bfc3RyZWFtaW5nKHN0cnVjdCB2 YjJfcXVldWUgKnF1ZXVlKQogCiAJbWVkaWFfcGlwZWxpbmVfc3RvcCgmY2FwdHVyZS0+dmlkZW9f ZGV2LmVudGl0eSk7CiAKLQkvKiBSZWxlYXNlIGFsbCBhY3RpdmUgYnVmZmVycyAqLwotCXNwaW5f bG9ja19pcnFzYXZlKCZjYXB0dXJlLT5kbWFfcXVldWVfbG9jaywgZmxhZ3MpOwotCWxpc3RfZm9y X2VhY2hfZW50cnkoYnVmLCAmY2FwdHVyZS0+ZG1hX3F1ZXVlLCBsaXN0KQotCQl2YjJfYnVmZmVy X2RvbmUoJmJ1Zi0+djRsMl9idWZmZXIudmIyX2J1ZiwgVkIyX0JVRl9TVEFURV9FUlJPUik7Ci0J SU5JVF9MSVNUX0hFQUQoJmNhcHR1cmUtPmRtYV9xdWV1ZSk7Ci0Jc3Bpbl91bmxvY2tfaXJxcmVz dG9yZSgmY2FwdHVyZS0+ZG1hX3F1ZXVlX2xvY2ssIGZsYWdzKTsKLX0KLQotdm9pZCBzdW42aV9j c2lfY2FwdHVyZV9mcmFtZV9kb25lKHN0cnVjdCBzdW42aV9jc2lfZGV2aWNlICpjc2lfZGV2KQot ewotCXN0cnVjdCBzdW42aV9jc2lfY2FwdHVyZSAqY2FwdHVyZSA9ICZjc2lfZGV2LT5jYXB0dXJl OwotCXN0cnVjdCBzdW42aV9jc2lfYnVmZmVyICpidWY7Ci0Jc3RydWN0IHN1bjZpX2NzaV9idWZm ZXIgKm5leHRfYnVmOwotCXN0cnVjdCB2YjJfdjRsMl9idWZmZXIgKnY0bDJfYnVmZmVyOwotCi0J c3Bpbl9sb2NrKCZjYXB0dXJlLT5kbWFfcXVldWVfbG9jayk7Ci0KLQlidWYgPSBsaXN0X2ZpcnN0 X2VudHJ5KCZjYXB0dXJlLT5kbWFfcXVldWUsCi0JCQkgICAgICAgc3RydWN0IHN1bjZpX2NzaV9i dWZmZXIsIGxpc3QpOwotCWlmIChsaXN0X2lzX2xhc3QoJmJ1Zi0+bGlzdCwgJmNhcHR1cmUtPmRt YV9xdWV1ZSkpIHsKLQkJZGV2X2RiZyhjc2lfZGV2LT5kZXYsICJGcmFtZSBkcm9wcGVkIVxuIik7 Ci0JCWdvdG8gY29tcGxldGU7Ci0JfQotCi0JbmV4dF9idWYgPSBsaXN0X25leHRfZW50cnkoYnVm LCBsaXN0KTsKLQkvKiBJZiBhIG5ldyBidWZmZXIgKCNuZXh0X2J1ZikgaGFkIG5vdCBiZWVuIHF1 ZXVlZCB0byBDU0ksIHRoZSBvbGQKLQkgKiBidWZmZXIgKCNidWYpIGlzIHN0aWxsIGhvbGRpbmcg YnkgQ1NJIGZvciBzdG9yaW5nIHRoZSBuZXh0Ci0JICogZnJhbWUuIFNvLCB3ZSBxdWV1ZSBhIG5l dyBidWZmZXIgKCNuZXh0X2J1ZikgdG8gQ1NJIHRoZW4gd2FpdAotCSAqIGZvciBuZXh0IElTUiBj YWxsLgotCSAqLwotCWlmICghbmV4dF9idWYtPnF1ZXVlZF90b19jc2kpIHsKLQkJc3VuNmlfY3Np X2NhcHR1cmVfYnVmZmVyX2NvbmZpZ3VyZShjc2lfZGV2LCBuZXh0X2J1Zik7Ci0JCWRldl9kYmco Y3NpX2Rldi0+ZGV2LCAiRnJhbWUgZHJvcHBlZCFcbiIpOwotCQlnb3RvIGNvbXBsZXRlOwotCX0K LQotCWxpc3RfZGVsKCZidWYtPmxpc3QpOwotCXY0bDJfYnVmZmVyID0gJmJ1Zi0+djRsMl9idWZm ZXI7Ci0JdjRsMl9idWZmZXItPnZiMl9idWYudGltZXN0YW1wID0ga3RpbWVfZ2V0X25zKCk7Ci0J djRsMl9idWZmZXItPnNlcXVlbmNlID0gY2FwdHVyZS0+c2VxdWVuY2U7Ci0JdmIyX2J1ZmZlcl9k b25lKCZ2NGwyX2J1ZmZlci0+dmIyX2J1ZiwgVkIyX0JVRl9TVEFURV9ET05FKTsKLQotCS8qIFBy ZXBhcmUgYnVmZmVyIGZvciBuZXh0IGZyYW1lIGJ1dCBvbmUuICAqLwotCWlmICghbGlzdF9pc19s YXN0KCZuZXh0X2J1Zi0+bGlzdCwgJmNhcHR1cmUtPmRtYV9xdWV1ZSkpIHsKLQkJbmV4dF9idWYg PSBsaXN0X25leHRfZW50cnkobmV4dF9idWYsIGxpc3QpOwotCQlzdW42aV9jc2lfY2FwdHVyZV9i dWZmZXJfY29uZmlndXJlKGNzaV9kZXYsIG5leHRfYnVmKTsKLQl9IGVsc2UgewotCQlkZXZfZGJn KGNzaV9kZXYtPmRldiwgIk5leHQgZnJhbWUgd2lsbCBiZSBkcm9wcGVkIVxuIik7Ci0JfQotCi1j b21wbGV0ZToKLQljYXB0dXJlLT5zZXF1ZW5jZSsrOwotCXNwaW5fdW5sb2NrKCZjYXB0dXJlLT5k bWFfcXVldWVfbG9jayk7CisJc3VuNmlfY3NpX2NhcHR1cmVfc3RhdGVfY2xlYW51cChjc2lfZGV2 LCB0cnVlKTsKIH0KIAogc3RhdGljIGNvbnN0IHN0cnVjdCB2YjJfb3BzIHN1bjZpX2NzaV9jYXB0 dXJlX3F1ZXVlX29wcyA9IHsKQEAgLTYzOSw2ICs2NzEsNyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0 IG1lZGlhX2VudGl0eV9vcGVyYXRpb25zIHN1bjZpX2NzaV9jYXB0dXJlX21lZGlhX29wcyA9IHsK IGludCBzdW42aV9jc2lfY2FwdHVyZV9zZXR1cChzdHJ1Y3Qgc3VuNmlfY3NpX2RldmljZSAqY3Np X2RldikKIHsKIAlzdHJ1Y3Qgc3VuNmlfY3NpX2NhcHR1cmUgKmNhcHR1cmUgPSAmY3NpX2Rldi0+ Y2FwdHVyZTsKKwlzdHJ1Y3Qgc3VuNmlfY3NpX2NhcHR1cmVfc3RhdGUgKnN0YXRlID0gJmNhcHR1 cmUtPnN0YXRlOwogCXN0cnVjdCB2NGwyX2RldmljZSAqdjRsMl9kZXYgPSAmY3NpX2Rldi0+djRs Mi52NGwyX2RldjsKIAlzdHJ1Y3QgdjRsMl9zdWJkZXYgKmJyaWRnZV9zdWJkZXYgPSAmY3NpX2Rl di0+YnJpZGdlLnN1YmRldjsKIAlzdHJ1Y3QgdmlkZW9fZGV2aWNlICp2aWRlb19kZXYgPSAmY2Fw dHVyZS0+dmlkZW9fZGV2OwpAQCAtNjQ4LDYgKzY4MSwxMSBAQCBpbnQgc3VuNmlfY3NpX2NhcHR1 cmVfc2V0dXAoc3RydWN0IHN1bjZpX2NzaV9kZXZpY2UgKmNzaV9kZXYpCiAJc3RydWN0IHY0bDJf cGl4X2Zvcm1hdCAqcGl4X2Zvcm1hdCA9ICZmb3JtYXQuZm10LnBpeDsKIAlpbnQgcmV0OwogCisJ LyogU3RhdGUgKi8KKworCUlOSVRfTElTVF9IRUFEKCZzdGF0ZS0+cXVldWUpOworCXNwaW5fbG9j a19pbml0KCZzdGF0ZS0+bG9jayk7CisKIAkvKiBNZWRpYSBFbnRpdHkgKi8KIAogCXZpZGVvX2Rl di0+ZW50aXR5Lm9wcyA9ICZzdW42aV9jc2lfY2FwdHVyZV9tZWRpYV9vcHM7CkBAIC02NjAsMTMg KzY5OCw2IEBAIGludCBzdW42aV9jc2lfY2FwdHVyZV9zZXR1cChzdHJ1Y3Qgc3VuNmlfY3NpX2Rl dmljZSAqY3NpX2RldikKIAlpZiAocmV0IDwgMCkKIAkJcmV0dXJuIHJldDsKIAotCS8qIERNQSBx dWV1ZSAqLwotCi0JSU5JVF9MSVNUX0hFQUQoJmNhcHR1cmUtPmRtYV9xdWV1ZSk7Ci0Jc3Bpbl9s b2NrX2luaXQoJmNhcHR1cmUtPmRtYV9xdWV1ZV9sb2NrKTsKLQotCWNhcHR1cmUtPnNlcXVlbmNl ID0gMDsKLQogCS8qIFF1ZXVlICovCiAKIAltdXRleF9pbml0KCZjYXB0dXJlLT5sb2NrKTsKQEAg LTY3NiwxNCArNzA3LDEyIEBAIGludCBzdW42aV9jc2lfY2FwdHVyZV9zZXR1cChzdHJ1Y3Qgc3Vu NmlfY3NpX2RldmljZSAqY3NpX2RldikKIAlxdWV1ZS0+YnVmX3N0cnVjdF9zaXplID0gc2l6ZW9m KHN0cnVjdCBzdW42aV9jc2lfYnVmZmVyKTsKIAlxdWV1ZS0+b3BzID0gJnN1bjZpX2NzaV9jYXB0 dXJlX3F1ZXVlX29wczsKIAlxdWV1ZS0+bWVtX29wcyA9ICZ2YjJfZG1hX2NvbnRpZ19tZW1vcHM7 CisJcXVldWUtPm1pbl9idWZmZXJzX25lZWRlZCA9IDI7CiAJcXVldWUtPnRpbWVzdGFtcF9mbGFn cyA9IFY0TDJfQlVGX0ZMQUdfVElNRVNUQU1QX01PTk9UT05JQzsKIAlxdWV1ZS0+bG9jayA9ICZj YXB0dXJlLT5sb2NrOwogCXF1ZXVlLT5kZXYgPSBjc2lfZGV2LT5kZXY7CiAJcXVldWUtPmRydl9w cml2ID0gY3NpX2RldjsKIAotCS8qIE1ha2Ugc3VyZSBub24tZHJvcHBlZCBmcmFtZS4gKi8KLQlx dWV1ZS0+bWluX2J1ZmZlcnNfbmVlZGVkID0gMzsKLQogCXJldCA9IHZiMl9xdWV1ZV9pbml0KHF1 ZXVlKTsKIAlpZiAocmV0KSB7CiAJCXY0bDJfZXJyKHY0bDJfZGV2LCAiZmFpbGVkIHRvIGluaXRp YWxpemUgdmIyIHF1ZXVlOiAlZFxuIiwgcmV0KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEv cGxhdGZvcm0vc3VueGkvc3VuNmktY3NpL3N1bjZpX2NzaV9jYXB0dXJlLmggYi9kcml2ZXJzL21l ZGlhL3BsYXRmb3JtL3N1bnhpL3N1bjZpLWNzaS9zdW42aV9jc2lfY2FwdHVyZS5oCmluZGV4IDM2 YmJhMzFmY2I0OC4uN2ZhNjZhMmFmNWVjIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3BsYXRm b3JtL3N1bnhpL3N1bjZpLWNzaS9zdW42aV9jc2lfY2FwdHVyZS5oCisrKyBiL2RyaXZlcnMvbWVk aWEvcGxhdGZvcm0vc3VueGkvc3VuNmktY3NpL3N1bjZpX2NzaV9jYXB0dXJlLmgKQEAgLTEzLDIz ICsxMywzNCBAQAogCiBzdHJ1Y3Qgc3VuNmlfY3NpX2RldmljZTsKIAorI3VuZGVmIGN1cnJlbnQK K3N0cnVjdCBzdW42aV9jc2lfY2FwdHVyZV9zdGF0ZSB7CisJc3RydWN0IGxpc3RfaGVhZAkJcXVl dWU7CisJc3BpbmxvY2tfdAkJCWxvY2s7IC8qIFF1ZXVlIGFuZCBidWZmZXJzIGxvY2suICovCisK KwlzdHJ1Y3Qgc3VuNmlfY3NpX2J1ZmZlcgkJKnBlbmRpbmc7CisJc3RydWN0IHN1bjZpX2NzaV9i dWZmZXIJCSpjdXJyZW50OworCXN0cnVjdCBzdW42aV9jc2lfYnVmZmVyCQkqY29tcGxldGU7CisK Kwl1bnNpZ25lZCBpbnQJCQlzZXF1ZW5jZTsKK307CisKIHN0cnVjdCBzdW42aV9jc2lfY2FwdHVy ZSB7CisJc3RydWN0IHN1bjZpX2NzaV9jYXB0dXJlX3N0YXRlCXN0YXRlOworCiAJc3RydWN0IHZp ZGVvX2RldmljZQkJdmlkZW9fZGV2OwogCXN0cnVjdCB2YjJfcXVldWUJCXF1ZXVlOwogCXN0cnVj dCBtdXRleAkJCWxvY2s7IC8qIFF1ZXVlIGxvY2suICovCiAJc3RydWN0IG1lZGlhX3BhZAkJcGFk OwogCi0Jc3RydWN0IGxpc3RfaGVhZAkJZG1hX3F1ZXVlOwotCXNwaW5sb2NrX3QJCQlkbWFfcXVl dWVfbG9jazsgLyogRE1BIHF1ZXVlIGxvY2suICovCi0KIAlzdHJ1Y3QgdjRsMl9mb3JtYXQJCWZv cm1hdDsKIAl1MzIJCQkJbWJ1c19jb2RlOwotCXVuc2lnbmVkIGludAkJCXNlcXVlbmNlOwogfTsK IAordm9pZCBzdW42aV9jc2lfY2FwdHVyZV9zeW5jKHN0cnVjdCBzdW42aV9jc2lfZGV2aWNlICpj c2lfZGV2KTsKK3ZvaWQgc3VuNmlfY3NpX2NhcHR1cmVfZnJhbWVfZG9uZShzdHJ1Y3Qgc3VuNmlf Y3NpX2RldmljZSAqY3NpX2Rldik7CisKIGludCBzdW42aV9jc2lfY2FwdHVyZV9zZXR1cChzdHJ1 Y3Qgc3VuNmlfY3NpX2RldmljZSAqY3NpX2Rldik7CiB2b2lkIHN1bjZpX2NzaV9jYXB0dXJlX2Ns ZWFudXAoc3RydWN0IHN1bjZpX2NzaV9kZXZpY2UgKmNzaV9kZXYpOwogCi12b2lkIHN1bjZpX2Nz aV9jYXB0dXJlX2ZyYW1lX2RvbmUoc3RydWN0IHN1bjZpX2NzaV9kZXZpY2UgKmNzaV9kZXYpOwot CiAjZW5kaWYgLyogX19TVU42SV9DQVBUVVJFX0hfXyAqLwotLSAKMi4zNS4yCgoKX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgtYXJtLWtlcm5lbCBt YWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9s aXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtYXJtLWtlcm5lbAo=