From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (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 5F56227CCF0 for ; Sat, 25 Jul 2026 05:04:39 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784955884; cv=none; b=ZTvdTGmQVnDHRu8rg1pbHgxa2+gj1eGTisPVZq0hHMhuVRY/Cjni68WjGUZPIeBshewt2Xf5IxfCFEkNNWJ6hYi//my9ew6di0bFZy5rC20K8AOtyaijYMBij+PWUG3w9Mg/eldEMMdYwi2mD9RncYomfOfSj13FczYhsMX0u5o= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784955884; c=relaxed/simple; bh=j5zs0qqmlZQkZizMqCkLV6COguQKY8FHVFgCxXBdRRY=; h=From:Subject:To:Cc:In-Reply-To:References:Content-Type:Date: Message-Id; b=CBMfnUQUQxnpLeteMU15CMptukVXSjlp/sq01QRTM34/HIEyKbXI6ZobaXRy+OWD3oxWTG5cuFqxcq0u6iT+VR1/g7W76Mw0tpnJ5qpUOAcDBOkqBlxIbwKcwoEk4tR8RcE4LbbMChLS3/3rkuztjRATL5tdWKRsOiqfIdrFWNc= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=awMd5Abg; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="awMd5Abg" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 2A4CB1F00A3A; Sat, 25 Jul 2026 05:04:39 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784955879; bh=5XEF+qAkWLuT5nSe/bguE8gYGpt4U9yK4reEWVi3igs=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=awMd5Abg8UavHKA/stIUBpgXUGPnMi3cgoP7b4Hzg0BxqAXk7CevaHQB6f7uPnSOg JlyXRr0Luxl19BxhG5MKtSDda7cWVnxcZVQsWUjF2KLfJCRcWZppM8Vc++0Eb6IWCe N5YGoR4EcHHai+n30Y/jQftugbzNZq4nvz3zGd/yDMOkWtiLCjgHCjrul9guyZA1He ZLPAUXSRNjN8lFNXGxmAsT0jrdX8W2kJrG+RI1bPz0UyW74YkG+xH42lfw7WUTOcZ1 SV/LZicOovhAol2woZzmuz64+Rw4frA7BpuJWuTMYY0XyrXPlv0ahcpDpRSdTCdQgs NIKhHyV68rGGQ== From: sashiko-bot@kernel.org Subject: Re: [PATCH RESEND 08/17] drm/spacemit: add Saturn DPU core types, cmdlist and display MMU Reply-To: sashiko-reviews@lists.linux.dev To: "Cody Kang" Cc: conor+dt@kernel.org, linux-phy@lists.infradead.org, vkoul@kernel.org, neil.armstrong@linaro.org, dri-devel@lists.freedesktop.org, devicetree@vger.kernel.org, robh@kernel.org, olteanv@gmail.com In-Reply-To: <20260725-k3-display-v1-8-6de34d80e86c@gmail.com> References: <20260725-k3-display-v1-0-6de34d80e86c@gmail.com> <20260725-k3-display-v1-8-6de34d80e86c@gmail.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Date: Sat, 25 Jul 2026 05:04:38 +0000 Message-Id: <20260725050439.2A4CB1F00A3A@smtp.kernel.org> Precedence: bulk X-Mailing-List: devicetree@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Thank you for your contribution! Sashiko AI review found 12 potential issue= (s) to consider: - [Critical] DMMU page table size calculation underflow allows arbitrary ph= ysical memory access. - [Critical] Shallow copy of DMA buffers in atomic state causes active disp= lay corruption. - [High] crtc_cmdlist_atomic_commit() passes a guaranteed NULL pointer to t= he hardware command list execution callback. - [High] Global `cmdlist_groups` array causes data races across concurrent = atomic commits. - [High] Unconditional dereference of `first_cl` in `cmdlist_atomic_commit(= )` causes a kernel panic if the command list group is empty. - [High] DMMU maps only the first GEM object, breaking multi-planar framebu= ffers. - [High] NULL pointer dereference in `dpu_plane_info` tracepoint. - [High] Sleeping in atomic context via `drm_gem_shmem_get_pages_sgt()`. - [High] Missing bounds check on `nod_len` causes DMA buffer overflow. - [Medium] Unaligned base virtual addresses are used for DMMU translation r= egions. - [Medium] Memory leak of DMA buffers upon atomic state destruction. - [Medium] Speculative array out-of-bounds access in `cmdlist_sort_by_group= ()`. -- --- Patch [8]: [PATCH RESEND 08/17] drm/spacemit: add Saturn DPU core types= , cmdlist and display MMU --- commit dc983d68951c3577447bb897e17c833e557da908 Author: Cody Kang drm/spacemit: add Saturn DPU core types, cmdlist and display MMU This commit introduces the shared driver types, MMIO accessors, trace events, command-list builder, and DMMU table code for the Saturn DPU. It enables batched register programming by building per-module register lists in memory, which the hardware command-list engine replays. > diff --git a/drivers/gpu/drm/spacemit/dpu/dpu_trace.h b/drivers/gpu/drm/s= pacemit/dpu/dpu_trace.h > index 0000000000000..abfe34a67a4bd 100644 > --- /dev/null > +++ b/drivers/gpu/drm/spacemit/dpu/dpu_trace.h [ ... ] > +TRACE_EVENT(dpu_plane_info, > + TP_PROTO(struct drm_plane_state *state, struct drm_framebuffer *fb, > + u32 rdma_id, u32 alpha, u32 rotation), > + TP_ARGS(state, fb, rdma_id, alpha, rotation), > + TP_STRUCT__entry( > + __field(u32, rdma_id) > + __field(u32, src_w) > + __field(u32, src_h) > + __field(u32, src_x) > + __field(u32, src_y) > + __field(u32, crtc_w) > + __field(u32, crtc_h) > + __field(u32, crtc_x) > + __field(u32, crtc_y) > + __field(u32, width) > + __field(u32, height) > + __field(u32, format) > + __field(u32, blend_mode) > + __field(u32, alpha) > + __field(u32, zpos) > + __field(u32, rotation) > + ), > + TP_fast_assign( > + __entry->rdma_id =3D rdma_id; > + __entry->src_w =3D state->src_w >> 16; > + __entry->src_h =3D state->src_h >> 16; > + __entry->src_x =3D state->src_x >> 16; > + __entry->src_y =3D state->src_y >> 16; > + __entry->crtc_w =3D state->crtc_w; > + __entry->crtc_h =3D state->crtc_h; > + __entry->crtc_x =3D state->crtc_x; > + __entry->crtc_y =3D state->crtc_y; > + __entry->width =3D fb->width; > + __entry->height =3D fb->height; > + __entry->format =3D fb->format->format; [Severity: High] Can this dereference a NULL pointer? When a plane is disabled during an atomic commit, state->fb might be NULL. Unconditionally reading fb->width here could cause a kernel panic if tracing is enabled. > + __entry->blend_mode =3D state->pixel_blend_mode; > + __entry->alpha =3D alpha; > + __entry->zpos =3D state->zpos; > + __entry->rotation =3D rotation; > + ), [ ... ] > diff --git a/drivers/gpu/drm/spacemit/spacemit_cmdlist.c b/drivers/gpu/dr= m/spacemit/spacemit_cmdlist.c > index 0000000000000..787d38e9e135f 100644 > --- /dev/null > +++ b/drivers/gpu/drm/spacemit/spacemit_cmdlist.c [ ... ] > +void cmdlist_regs_packing(struct cmdlist *cl, enum cmdlist_mode_type mod, > + struct cmdlist_regs *cl_regs) > +{ [ ... ] > + for (i =3D 0; i < cl_regs->size;) { > + u32 value[CMDLIST_ROW_REGS] =3D {0x0}; > + u32 offset, strobe =3D 0; > + u8 regs_in_row =3D 0; > + > + if (cl_regs->flags[i]) { > + offset =3D cl_regs->base + i * sizeof(u32); > + for (u8 j =3D 0; j < CMDLIST_ROW_REGS; j++) { > + index =3D i + j; > + if (likely(index < cl_regs->size)) { > + if (cl_regs->flags[index]) { > + value[j] =3D reg_base[index]; > + regs_in_row++; > + strobe |=3D CMDLIST_REG_STROBE(j); > + } > + } else { > + break; > + } > + } > + hwdev->cmdlist_fill_data_row(cl, strobe, offset, value); > + /* > + * the row covers the whole window; a shorter stride > + * would revisit covered words as duplicate rows > + */ > + i +=3D CMDLIST_ROW_REGS; > + cl->nod_len++; [Severity: High] Is there a risk of overflowing the DMA command list buffer here? The loop increments cl->nod_len and writes to memory, but there doesn't seem to be a bounds check to ensure the packed rows do not exceed the allocated capacity in cl->size. > + } else { > + i++; > + } > + } > + > + drm_dbg(a_crtc->crtc.dev, "row_num =3D %d\n", cl->nod_len); > +} > + > +void cmdlist_sort_by_group(struct drm_crtc *crtc) > +{ > + struct cmdlist *first_cl; > + struct cmdlist *last_cl; > + struct cmdlist *p; > + struct cmdlist *prev; > + struct drm_plane *plane; > + struct spacemit_crtc_rdma *rdmas =3D > + to_spacemit_crtc_state(crtc->state)->rdmas; > + struct spacemit_drm_private *priv =3D crtc->dev->dev_private; > + > + drm_atomic_crtc_for_each_plane(plane, crtc) { > + struct spacemit_plane_state *spacemit_pstate =3D > + to_spacemit_plane_state(plane->state); > + u32 rdma_id =3D spacemit_pstate->rdma_id; > + > + first_cl =3D &spacemit_pstate->cl; > + if (!first_cl->va) > + continue; > + > + last_cl =3D first_cl; > + last_cl->next =3D NULL; > + > + rdmas[rdma_id].in_use =3D true; [Severity: Medium] Could rdma_id exceed the bounds of the array? It is used directly as an index for the rdmas array without checking if it is within hwdev->rdma_nums. > + if (priv->cmdlist_groups[rdma_id]) { [Severity: High] Does modifying the global priv->cmdlist_groups array here cause data races? Since this array is stored in the shared spacemit_drm_private structure, concurrent atomic commits on multiple CRTCs might overwrite each other's command lists without locking. > + p =3D priv->cmdlist_groups[rdma_id]; > + prev =3D NULL; > + while (p) { > + if (cl_to_spacemit_pstate(p)->state.crtc_y < > + spacemit_pstate->state.crtc_y) { > + prev =3D p; > + p =3D p->next; > + } else { > + break; > + } > + } > + if (!prev) { > + priv->cmdlist_groups[rdma_id] =3D first_cl; > + last_cl->next =3D p; > + } else { > + prev->next =3D first_cl; > + last_cl->next =3D p; > + } > + } else { > + priv->cmdlist_groups[rdma_id] =3D first_cl; > + } > + } > +} > + > +void cmdlist_atomic_commit(struct drm_crtc *crtc, > + struct drm_crtc_state *old_state) > +{ [ ... ] > + for (i =3D 0; i < hwdev->rdma_nums; i++) { > + if (old_rdmas[i].in_use) > + hwdev->enable_cmdlist(a_crtc, hwdev, i, false); > + > + if (cur_rdmas[i].in_use) { > + drm_dbg(crtc->dev, "cmdlist group =3D %d\n", i); > + cur_cl =3D priv->cmdlist_groups[i]; > + first_cl =3D cur_cl; > + while (cur_cl) { > + hwdev->cmdlist_fill_conf_row(cur_cl, hwdev, > + CMDLIST_CMP_INVALID); > + cmdlist_dump_node(cur_cl); > + cur_cl =3D cur_cl->next; > + } > + chy =3D cl_to_spacemit_pstate(first_cl)->state.crtc_y; [Severity: High] Could first_cl be NULL here? If cur_rdmas[i].in_use is true but priv->cmdlist_groups[i] is empty, first_cl would be NULL. This can happen if planes are removed from the state but in_use was copied as true from the old state. The cl_to_spacemit_pstate macro would yield a negative offset from NULL, resulting in a crash. > + addrl =3D (lower_32_bits(priv->cmdlist_groups[i]->pa) & > + CMDLIST_ADDRL_ALIGN_MASK) >> CMDLIST_ADDRL_ALIGN_BITS; > + > + addrh =3D upper_32_bits(priv->cmdlist_groups[i]->pa); > + hwdev->cfg_cmdlist(hwdev, i, chy, addrl, addrh); > + hwdev->enable_cmdlist(a_crtc, hwdev, i, true); > + priv->cmdlist_groups[i] =3D NULL; > + } > + } > +} > + [ ... ] > +void crtc_cmdlist_atomic_commit(struct spacemit_crtc *a_crtc) > +{ > + struct cmdlist *cur_cl; > + struct drm_crtc *crtc =3D &a_crtc->crtc; > + struct spacemit_drm_private *priv =3D crtc->dev->dev_private; > + struct spacemit_hw_device *hwdev =3D priv->hwdev; > + u8 crtc_id =3D drm_crtc_index(crtc); > + u8 dev_id =3D a_crtc->dev_id; > + > + drm_dbg(crtc->dev, "cmdlist group =3D %d\n", > + hwdev->rdma_nums + crtc_id); > + cur_cl =3D priv->cmdlist_groups[hwdev->rdma_nums + crtc_id]; > + while (cur_cl) { > + hwdev->cmdlist_fill_conf_row(cur_cl, hwdev, dev_id); > + cmdlist_dump_node(cur_cl); > + cur_cl =3D cur_cl->next; > + } > + hwdev->crtc_cmdlist(cur_cl, hwdev, priv, crtc_id, dev_id); [Severity: High] Does this pass a guaranteed NULL pointer to the hardware callback? The while loop exhausts cur_cl to NULL, which is then immediately passed to hwdev->crtc_cmdlist. It looks like the head of the list should be passed instead. > +} > + > +/* Called from atomic_check(), where -ENOMEM is still an answer. */ > +int spacemit_cmdlist_alloc(struct device *dev, struct cmdlist *cl) > +{ > + if (cl->va) > + return 0; [Severity: Critical] Does returning early when cl->va is present cause active display corruption? Because struct cmdlist is embedded directly in the plane state, DRM's state duplication will shallow-copy cl->va. If atomic_update mutates this same virtual address while the hardware is actively reading it from the old state, it could lead to screen tearing or DPU hangs. DMA buffers for command lists generally need to be multi-buffered or allocated per-state. > + > + cl->size =3D PER_CMDLIST_SIZE; > + cl->va =3D dma_alloc_coherent(dev, cl->size, &cl->pa, > + GFP_KERNEL | __GFP_ZERO); > + if (!cl->va) > + return -ENOMEM; [Severity: Medium] Is there a corresponding dma_free_coherent() during state destruction? If the allocated cl->va is never freed when the atomic state is destroyed, this might cause a steady leak of DMA memory. > + > + return 0; > +} [ ... ] > diff --git a/drivers/gpu/drm/spacemit/spacemit_dmmu.c b/drivers/gpu/drm/s= pacemit/spacemit_dmmu.c > index 0000000000000..2ae30dd1a4f23 100644 > --- /dev/null > +++ b/drivers/gpu/drm/spacemit/spacemit_dmmu.c [ ... ] > +int spacemit_dmmu_map(struct drm_framebuffer *fb, struct dpu_mmu_tbl *mm= u_tbl, > + u8 tbu_id, struct cmdlist_regs *cl_rdma, > + struct drm_plane *plane) > +{ > + struct spacemit_drm_private *priv =3D fb->dev->dev_private; > + struct spacemit_hw_device *hwdev =3D priv->hwdev; > + const struct drm_format_info *format =3D NULL; > + struct sg_table *sgt =3D NULL; > + u32 total_size, offset1, offset2; > + struct tbu_instance tbu =3D { }; > + u8 plane_num; > + u32 val; > + > + format =3D fb->format; > + sgt =3D drm_gem_shmem_get_pages_sgt(to_drm_gem_shmem_obj(fb->obj[0])); [Severity: High] Will this sleep in atomic context? This function appears to be called during hardware programming in the atomic commit phase. Calling drm_gem_shmem_get_pages_sgt allocates memory and can acquire a mutex, which is forbidden in atomic context. Buffer mapping typically needs to be deferred to the sleepable prepare_fb callback. [Severity: High] Does mapping only fb->obj[0] break multi-planar framebuffers? If userspace provides a multi-planar framebuffer where the planes reside in different GEM objects, extracting the SG table only for obj[0] will result in incorrect physical memory pages for the secondary planes. > + if (IS_ERR(sgt)) > + return PTR_ERR(sgt); > + > + plane_num =3D format->num_planes; > + > + total_size =3D roundup(fb->obj[0]->size, PAGE_SIZE); > + > + offset1 =3D plane_num > 1 ? fb->offsets[1] : total_size; > + offset2 =3D plane_num > 2 ? fb->offsets[2] : total_size; > + > + switch (plane_num) { > + case 3: > + tbu.ttb_pa[2] =3D mmu_tbl->pa + (offset2 >> PAGE_SHIFT) * 4; > + tbu.tbu_va[2] =3D TBU_BASE_VA(tbu_id) + offset2; [Severity: Medium] Could adding offset2 directly to TBU_BASE_VA result in unaligned base virtual addresses? If userspace supplies an offset that is not a multiple of PAGE_SIZE, programming an unaligned virtual address might confuse the hardware MMU. > + tbu.ttb_size[2] =3D PAGE_ALIGN(total_size - rounddown(offset2, PAGE_SI= ZE)) > + >> PAGE_SHIFT; [Severity: Critical] Can this size calculation underflow? If a malicious userspace client provides offset2 smaller than offset1, the unsigned subtraction offset2 - rounddown(offset1, PAGE_SIZE) will underflow to a massive positive value. This could program the DMMU with a huge translation block, allowing arbitrary out-of-bounds physical memory reads. > + fallthrough; > + case 2: > + tbu.ttb_pa[1] =3D mmu_tbl->pa + (offset1 >> PAGE_SHIFT) * 4; > + tbu.tbu_va[1] =3D TBU_BASE_VA(tbu_id) + offset1; > + tbu.ttb_size[1] =3D PAGE_ALIGN(offset2 - rounddown(offset1, PAGE_SIZE)= ) >> PAGE_SHIFT; > + fallthrough; > + case 1: > + tbu.ttb_pa[0] =3D mmu_tbl->pa; > + tbu.tbu_va[0] =3D TBU_BASE_VA(tbu_id); > + tbu.ttb_size[0] =3D PAGE_ALIGN(offset1) >> PAGE_SHIFT; > + fallthrough; > + default: > + break; > + } [ ... ] --=20 Sashiko AI review =C2=B7 https://sashiko.dev/#/patchset/20260725-k3-display= -v1-0-6de34d80e86c@gmail.com?part=3D8 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 44948C531C9 for ; Sat, 25 Jul 2026 05:04:41 +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:MIME-Version:Reply-To:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:Message-Id:Date: References:In-Reply-To:Cc:To:Subject:From:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=TKc8a361rJjwIOYynZqquAjByMNZt90xrD0y9FRwEK0=; b=GCIzWToCx64p/H sGC07S0thn8kx/LwIlMlAGD2Jtcto9lYfY5OTThL822jxxI2IPj3AVwq321/6NPvZidWQoEn9C3ww ff92q/gUb0MvnR+0ZOkE8QvQpxO7dHgrQR90Woqeveu+RxtLV8I6yyKdR1hK5I6ZLl8FJ/ZmWnZLQ Ob/xSl84iB+gmBeSFP4LeppgDfMI2n68G+bmM82P9sJ/2UlKcWdWnEigFO0Qfr8vi3mngefMS4OFY /HhGUOGyHqPfBs79VokTiOFhmIJW4FwHO8nCr9D/IxsIsIYn0wwgmO4yNZf60QHTNMcCOJnz8HpUR Iffy+KHfBHZO21p9bczA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1wnUYz-000000002sB-01RR; Sat, 25 Jul 2026 05:04:41 +0000 Received: from sea.source.kernel.org ([172.234.252.31]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1wnUYx-000000002rt-43Vs for linux-phy@lists.infradead.org; Sat, 25 Jul 2026 05:04:40 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id B5E7340AC4; Sat, 25 Jul 2026 05:04:39 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 2A4CB1F00A3A; Sat, 25 Jul 2026 05:04:39 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784955879; bh=5XEF+qAkWLuT5nSe/bguE8gYGpt4U9yK4reEWVi3igs=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=awMd5Abg8UavHKA/stIUBpgXUGPnMi3cgoP7b4Hzg0BxqAXk7CevaHQB6f7uPnSOg JlyXRr0Luxl19BxhG5MKtSDda7cWVnxcZVQsWUjF2KLfJCRcWZppM8Vc++0Eb6IWCe N5YGoR4EcHHai+n30Y/jQftugbzNZq4nvz3zGd/yDMOkWtiLCjgHCjrul9guyZA1He ZLPAUXSRNjN8lFNXGxmAsT0jrdX8W2kJrG+RI1bPz0UyW74YkG+xH42lfw7WUTOcZ1 SV/LZicOovhAol2woZzmuz64+Rw4frA7BpuJWuTMYY0XyrXPlv0ahcpDpRSdTCdQgs NIKhHyV68rGGQ== From: sashiko-bot@kernel.org Subject: Re: [PATCH RESEND 08/17] drm/spacemit: add Saturn DPU core types, cmdlist and display MMU To: "Cody Kang" Cc: conor+dt@kernel.org, linux-phy@lists.infradead.org, vkoul@kernel.org, neil.armstrong@linaro.org, dri-devel@lists.freedesktop.org, devicetree@vger.kernel.org, robh@kernel.org, olteanv@gmail.com In-Reply-To: <20260725-k3-display-v1-8-6de34d80e86c@gmail.com> References: <20260725-k3-display-v1-0-6de34d80e86c@gmail.com> <20260725-k3-display-v1-8-6de34d80e86c@gmail.com> Date: Sat, 25 Jul 2026 05:04:38 +0000 Message-Id: <20260725050439.2A4CB1F00A3A@smtp.kernel.org> X-BeenThere: linux-phy@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Linux Phy Mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: sashiko-reviews@lists.linux.dev MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-phy" Errors-To: linux-phy-bounces+linux-phy=archiver.kernel.org@lists.infradead.org VGhhbmsgeW91IGZvciB5b3VyIGNvbnRyaWJ1dGlvbiEgU2FzaGlrbyBBSSByZXZpZXcgZm91bmQg MTIgcG90ZW50aWFsIGlzc3VlKHMpIHRvIGNvbnNpZGVyOgotIFtDcml0aWNhbF0gRE1NVSBwYWdl IHRhYmxlIHNpemUgY2FsY3VsYXRpb24gdW5kZXJmbG93IGFsbG93cyBhcmJpdHJhcnkgcGh5c2lj YWwgbWVtb3J5IGFjY2Vzcy4KLSBbQ3JpdGljYWxdIFNoYWxsb3cgY29weSBvZiBETUEgYnVmZmVy cyBpbiBhdG9taWMgc3RhdGUgY2F1c2VzIGFjdGl2ZSBkaXNwbGF5IGNvcnJ1cHRpb24uCi0gW0hp Z2hdIGNydGNfY21kbGlzdF9hdG9taWNfY29tbWl0KCkgcGFzc2VzIGEgZ3VhcmFudGVlZCBOVUxM IHBvaW50ZXIgdG8gdGhlIGhhcmR3YXJlIGNvbW1hbmQgbGlzdCBleGVjdXRpb24gY2FsbGJhY2su Ci0gW0hpZ2hdIEdsb2JhbCBgY21kbGlzdF9ncm91cHNgIGFycmF5IGNhdXNlcyBkYXRhIHJhY2Vz IGFjcm9zcyBjb25jdXJyZW50IGF0b21pYyBjb21taXRzLgotIFtIaWdoXSBVbmNvbmRpdGlvbmFs IGRlcmVmZXJlbmNlIG9mIGBmaXJzdF9jbGAgaW4gYGNtZGxpc3RfYXRvbWljX2NvbW1pdCgpYCBj YXVzZXMgYSBrZXJuZWwgcGFuaWMgaWYgdGhlIGNvbW1hbmQgbGlzdCBncm91cCBpcyBlbXB0eS4K LSBbSGlnaF0gRE1NVSBtYXBzIG9ubHkgdGhlIGZpcnN0IEdFTSBvYmplY3QsIGJyZWFraW5nIG11 bHRpLXBsYW5hciBmcmFtZWJ1ZmZlcnMuCi0gW0hpZ2hdIE5VTEwgcG9pbnRlciBkZXJlZmVyZW5j ZSBpbiBgZHB1X3BsYW5lX2luZm9gIHRyYWNlcG9pbnQuCi0gW0hpZ2hdIFNsZWVwaW5nIGluIGF0 b21pYyBjb250ZXh0IHZpYSBgZHJtX2dlbV9zaG1lbV9nZXRfcGFnZXNfc2d0KClgLgotIFtIaWdo XSBNaXNzaW5nIGJvdW5kcyBjaGVjayBvbiBgbm9kX2xlbmAgY2F1c2VzIERNQSBidWZmZXIgb3Zl cmZsb3cuCi0gW01lZGl1bV0gVW5hbGlnbmVkIGJhc2UgdmlydHVhbCBhZGRyZXNzZXMgYXJlIHVz ZWQgZm9yIERNTVUgdHJhbnNsYXRpb24gcmVnaW9ucy4KLSBbTWVkaXVtXSBNZW1vcnkgbGVhayBv ZiBETUEgYnVmZmVycyB1cG9uIGF0b21pYyBzdGF0ZSBkZXN0cnVjdGlvbi4KLSBbTWVkaXVtXSBT cGVjdWxhdGl2ZSBhcnJheSBvdXQtb2YtYm91bmRzIGFjY2VzcyBpbiBgY21kbGlzdF9zb3J0X2J5 X2dyb3VwKClgLgotLQoKLS0tIFBhdGNoIFs4XTogW1BBVENIIFJFU0VORCAwOC8xN10gZHJtL3Nw YWNlbWl0OiBhZGQgU2F0dXJuIERQVSBjb3JlIHR5cGVzLCBjbWRsaXN0IGFuZCBkaXNwbGF5IE1N VSAtLS0KY29tbWl0IGRjOTgzZDY4OTUxYzM1Nzc0NDdiYjg5N2UxN2M4MzNlNTU3ZGE5MDgKQXV0 aG9yOiBDb2R5IEthbmcgPGNvZHlrYW5nLmhrQGdtYWlsLmNvbT4KCmRybS9zcGFjZW1pdDogYWRk IFNhdHVybiBEUFUgY29yZSB0eXBlcywgY21kbGlzdCBhbmQgZGlzcGxheSBNTVUKClRoaXMgY29t bWl0IGludHJvZHVjZXMgdGhlIHNoYXJlZCBkcml2ZXIgdHlwZXMsIE1NSU8gYWNjZXNzb3JzLCB0 cmFjZQpldmVudHMsIGNvbW1hbmQtbGlzdCBidWlsZGVyLCBhbmQgRE1NVSB0YWJsZSBjb2RlIGZv ciB0aGUgU2F0dXJuIERQVS4KSXQgZW5hYmxlcyBiYXRjaGVkIHJlZ2lzdGVyIHByb2dyYW1taW5n IGJ5IGJ1aWxkaW5nIHBlci1tb2R1bGUgcmVnaXN0ZXIKbGlzdHMgaW4gbWVtb3J5LCB3aGljaCB0 aGUgaGFyZHdhcmUgY29tbWFuZC1saXN0IGVuZ2luZSByZXBsYXlzLgoKPiBkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL3NwYWNlbWl0L2RwdS9kcHVfdHJhY2UuaCBiL2RyaXZlcnMvZ3B1L2Ry bS9zcGFjZW1pdC9kcHUvZHB1X3RyYWNlLmgKPiBpbmRleCAwMDAwMDAwMDAwMDAwLi5hYmZlMzRh NjdhNGJkIDEwMDY0NAo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vc3Bh Y2VtaXQvZHB1L2RwdV90cmFjZS5oClsgLi4uIF0KPiArVFJBQ0VfRVZFTlQoZHB1X3BsYW5lX2lu Zm8sCj4gKwkgICAgVFBfUFJPVE8oc3RydWN0IGRybV9wbGFuZV9zdGF0ZSAqc3RhdGUsIHN0cnVj dCBkcm1fZnJhbWVidWZmZXIgKmZiLAo+ICsJCSAgICAgdTMyIHJkbWFfaWQsIHUzMiBhbHBoYSwg dTMyIHJvdGF0aW9uKSwKPiArCVRQX0FSR1Moc3RhdGUsIGZiLCByZG1hX2lkLCBhbHBoYSwgcm90 YXRpb24pLAo+ICsJVFBfU1RSVUNUX19lbnRyeSgKPiArCQkJX19maWVsZCh1MzIsIHJkbWFfaWQp Cj4gKwkJCV9fZmllbGQodTMyLCBzcmNfdykKPiArCQkJX19maWVsZCh1MzIsIHNyY19oKQo+ICsJ CQlfX2ZpZWxkKHUzMiwgc3JjX3gpCj4gKwkJCV9fZmllbGQodTMyLCBzcmNfeSkKPiArCQkJX19m aWVsZCh1MzIsIGNydGNfdykKPiArCQkJX19maWVsZCh1MzIsIGNydGNfaCkKPiArCQkJX19maWVs ZCh1MzIsIGNydGNfeCkKPiArCQkJX19maWVsZCh1MzIsIGNydGNfeSkKPiArCQkJX19maWVsZCh1 MzIsIHdpZHRoKQo+ICsJCQlfX2ZpZWxkKHUzMiwgaGVpZ2h0KQo+ICsJCQlfX2ZpZWxkKHUzMiwg Zm9ybWF0KQo+ICsJCQlfX2ZpZWxkKHUzMiwgYmxlbmRfbW9kZSkKPiArCQkJX19maWVsZCh1MzIs IGFscGhhKQo+ICsJCQlfX2ZpZWxkKHUzMiwgenBvcykKPiArCQkJX19maWVsZCh1MzIsIHJvdGF0 aW9uKQo+ICsJKSwKPiArCVRQX2Zhc3RfYXNzaWduKAo+ICsJCQlfX2VudHJ5LT5yZG1hX2lkID0g cmRtYV9pZDsKPiArCQkJX19lbnRyeS0+c3JjX3cgPSBzdGF0ZS0+c3JjX3cgPj4gMTY7Cj4gKwkJ CV9fZW50cnktPnNyY19oID0gc3RhdGUtPnNyY19oID4+IDE2Owo+ICsJCQlfX2VudHJ5LT5zcmNf eCA9IHN0YXRlLT5zcmNfeCA+PiAxNjsKPiArCQkJX19lbnRyeS0+c3JjX3kgPSBzdGF0ZS0+c3Jj X3kgPj4gMTY7Cj4gKwkJCV9fZW50cnktPmNydGNfdyA9IHN0YXRlLT5jcnRjX3c7Cj4gKwkJCV9f ZW50cnktPmNydGNfaCA9IHN0YXRlLT5jcnRjX2g7Cj4gKwkJCV9fZW50cnktPmNydGNfeCA9IHN0 YXRlLT5jcnRjX3g7Cj4gKwkJCV9fZW50cnktPmNydGNfeSA9IHN0YXRlLT5jcnRjX3k7Cj4gKwkJ CV9fZW50cnktPndpZHRoID0gZmItPndpZHRoOwo+ICsJCQlfX2VudHJ5LT5oZWlnaHQgPSBmYi0+ aGVpZ2h0Owo+ICsJCQlfX2VudHJ5LT5mb3JtYXQgPSBmYi0+Zm9ybWF0LT5mb3JtYXQ7CgpbU2V2 ZXJpdHk6IEhpZ2hdCkNhbiB0aGlzIGRlcmVmZXJlbmNlIGEgTlVMTCBwb2ludGVyPyBXaGVuIGEg cGxhbmUgaXMgZGlzYWJsZWQgZHVyaW5nIGFuCmF0b21pYyBjb21taXQsIHN0YXRlLT5mYiBtaWdo dCBiZSBOVUxMLiBVbmNvbmRpdGlvbmFsbHkgcmVhZGluZyBmYi0+d2lkdGgKaGVyZSBjb3VsZCBj YXVzZSBhIGtlcm5lbCBwYW5pYyBpZiB0cmFjaW5nIGlzIGVuYWJsZWQuCgo+ICsJCQlfX2VudHJ5 LT5ibGVuZF9tb2RlID0gc3RhdGUtPnBpeGVsX2JsZW5kX21vZGU7Cj4gKwkJCV9fZW50cnktPmFs cGhhID0gYWxwaGE7Cj4gKwkJCV9fZW50cnktPnpwb3MgPSBzdGF0ZS0+enBvczsKPiArCQkJX19l bnRyeS0+cm90YXRpb24gPSByb3RhdGlvbjsKPiArCSksClsgLi4uIF0KPiBkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL3NwYWNlbWl0L3NwYWNlbWl0X2NtZGxpc3QuYyBiL2RyaXZlcnMvZ3B1 L2RybS9zcGFjZW1pdC9zcGFjZW1pdF9jbWRsaXN0LmMKPiBpbmRleCAwMDAwMDAwMDAwMDAwLi43 ODdkMzhlOWUxMzVmIDEwMDY0NAo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL2dwdS9k cm0vc3BhY2VtaXQvc3BhY2VtaXRfY21kbGlzdC5jClsgLi4uIF0KPiArdm9pZCBjbWRsaXN0X3Jl Z3NfcGFja2luZyhzdHJ1Y3QgY21kbGlzdCAqY2wsIGVudW0gY21kbGlzdF9tb2RlX3R5cGUgbW9k LAo+ICsJCQkgIHN0cnVjdCBjbWRsaXN0X3JlZ3MgKmNsX3JlZ3MpCj4gK3sKWyAuLi4gXQo+ICsJ Zm9yIChpID0gMDsgaSA8IGNsX3JlZ3MtPnNpemU7KSB7Cj4gKwkJdTMyIHZhbHVlW0NNRExJU1Rf Uk9XX1JFR1NdID0gezB4MH07Cj4gKwkJdTMyIG9mZnNldCwgc3Ryb2JlID0gMDsKPiArCQl1OCBy ZWdzX2luX3JvdyA9IDA7Cj4gKwo+ICsJCWlmIChjbF9yZWdzLT5mbGFnc1tpXSkgewo+ICsJCQlv ZmZzZXQgPSBjbF9yZWdzLT5iYXNlICsgaSAqIHNpemVvZih1MzIpOwo+ICsJCQlmb3IgKHU4IGog PSAwOyBqIDwgQ01ETElTVF9ST1dfUkVHUzsgaisrKSB7Cj4gKwkJCQlpbmRleCA9IGkgKyBqOwo+ ICsJCQkJaWYgKGxpa2VseShpbmRleCA8IGNsX3JlZ3MtPnNpemUpKSB7Cj4gKwkJCQkJaWYgKGNs X3JlZ3MtPmZsYWdzW2luZGV4XSkgewo+ICsJCQkJCQl2YWx1ZVtqXSA9IHJlZ19iYXNlW2luZGV4 XTsKPiArCQkJCQkJcmVnc19pbl9yb3crKzsKPiArCQkJCQkJc3Ryb2JlIHw9IENNRExJU1RfUkVH X1NUUk9CRShqKTsKPiArCQkJCQl9Cj4gKwkJCQl9IGVsc2Ugewo+ICsJCQkJCWJyZWFrOwo+ICsJ CQkJfQo+ICsJCQl9Cj4gKwkJCWh3ZGV2LT5jbWRsaXN0X2ZpbGxfZGF0YV9yb3coY2wsIHN0cm9i ZSwgb2Zmc2V0LCB2YWx1ZSk7Cj4gKwkJCS8qCj4gKwkJCSAqIHRoZSByb3cgY292ZXJzIHRoZSB3 aG9sZSB3aW5kb3c7IGEgc2hvcnRlciBzdHJpZGUKPiArCQkJICogd291bGQgcmV2aXNpdCBjb3Zl cmVkIHdvcmRzIGFzIGR1cGxpY2F0ZSByb3dzCj4gKwkJCSAqLwo+ICsJCQlpICs9IENNRExJU1Rf Uk9XX1JFR1M7Cj4gKwkJCWNsLT5ub2RfbGVuKys7CgpbU2V2ZXJpdHk6IEhpZ2hdCklzIHRoZXJl IGEgcmlzayBvZiBvdmVyZmxvd2luZyB0aGUgRE1BIGNvbW1hbmQgbGlzdCBidWZmZXIgaGVyZT8g VGhlIGxvb3AKaW5jcmVtZW50cyBjbC0+bm9kX2xlbiBhbmQgd3JpdGVzIHRvIG1lbW9yeSwgYnV0 IHRoZXJlIGRvZXNuJ3Qgc2VlbSB0byBiZQphIGJvdW5kcyBjaGVjayB0byBlbnN1cmUgdGhlIHBh Y2tlZCByb3dzIGRvIG5vdCBleGNlZWQgdGhlIGFsbG9jYXRlZApjYXBhY2l0eSBpbiBjbC0+c2l6 ZS4KCj4gKwkJfSBlbHNlIHsKPiArCQkJaSsrOwo+ICsJCX0KPiArCX0KPiArCj4gKwlkcm1fZGJn KGFfY3J0Yy0+Y3J0Yy5kZXYsICJyb3dfbnVtID0gJWRcbiIsIGNsLT5ub2RfbGVuKTsKPiArfQo+ ICsKPiArdm9pZCBjbWRsaXN0X3NvcnRfYnlfZ3JvdXAoc3RydWN0IGRybV9jcnRjICpjcnRjKQo+ ICt7Cj4gKwlzdHJ1Y3QgY21kbGlzdCAqZmlyc3RfY2w7Cj4gKwlzdHJ1Y3QgY21kbGlzdCAqbGFz dF9jbDsKPiArCXN0cnVjdCBjbWRsaXN0ICpwOwo+ICsJc3RydWN0IGNtZGxpc3QgKnByZXY7Cj4g KwlzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZTsKPiArCXN0cnVjdCBzcGFjZW1pdF9jcnRjX3JkbWEg KnJkbWFzID0KPiArCQkJdG9fc3BhY2VtaXRfY3J0Y19zdGF0ZShjcnRjLT5zdGF0ZSktPnJkbWFz Owo+ICsJc3RydWN0IHNwYWNlbWl0X2RybV9wcml2YXRlICpwcml2ID0gY3J0Yy0+ZGV2LT5kZXZf cHJpdmF0ZTsKPiArCj4gKwlkcm1fYXRvbWljX2NydGNfZm9yX2VhY2hfcGxhbmUocGxhbmUsIGNy dGMpIHsKPiArCQlzdHJ1Y3Qgc3BhY2VtaXRfcGxhbmVfc3RhdGUgKnNwYWNlbWl0X3BzdGF0ZSA9 Cj4gKwkJCXRvX3NwYWNlbWl0X3BsYW5lX3N0YXRlKHBsYW5lLT5zdGF0ZSk7Cj4gKwkJdTMyIHJk bWFfaWQgPSBzcGFjZW1pdF9wc3RhdGUtPnJkbWFfaWQ7Cj4gKwo+ICsJCWZpcnN0X2NsID0gJnNw YWNlbWl0X3BzdGF0ZS0+Y2w7Cj4gKwkJaWYgKCFmaXJzdF9jbC0+dmEpCj4gKwkJCWNvbnRpbnVl Owo+ICsKPiArCQlsYXN0X2NsID0gZmlyc3RfY2w7Cj4gKwkJbGFzdF9jbC0+bmV4dCA9IE5VTEw7 Cj4gKwo+ICsJCXJkbWFzW3JkbWFfaWRdLmluX3VzZSA9IHRydWU7CgpbU2V2ZXJpdHk6IE1lZGl1 bV0KQ291bGQgcmRtYV9pZCBleGNlZWQgdGhlIGJvdW5kcyBvZiB0aGUgYXJyYXk/IEl0IGlzIHVz ZWQgZGlyZWN0bHkgYXMgYW4KaW5kZXggZm9yIHRoZSByZG1hcyBhcnJheSB3aXRob3V0IGNoZWNr aW5nIGlmIGl0IGlzIHdpdGhpbiBod2Rldi0+cmRtYV9udW1zLgoKPiArCQlpZiAocHJpdi0+Y21k bGlzdF9ncm91cHNbcmRtYV9pZF0pIHsKCltTZXZlcml0eTogSGlnaF0KRG9lcyBtb2RpZnlpbmcg dGhlIGdsb2JhbCBwcml2LT5jbWRsaXN0X2dyb3VwcyBhcnJheSBoZXJlIGNhdXNlIGRhdGEgcmFj ZXM/ClNpbmNlIHRoaXMgYXJyYXkgaXMgc3RvcmVkIGluIHRoZSBzaGFyZWQgc3BhY2VtaXRfZHJt X3ByaXZhdGUgc3RydWN0dXJlLApjb25jdXJyZW50IGF0b21pYyBjb21taXRzIG9uIG11bHRpcGxl IENSVENzIG1pZ2h0IG92ZXJ3cml0ZSBlYWNoIG90aGVyJ3MKY29tbWFuZCBsaXN0cyB3aXRob3V0 IGxvY2tpbmcuCgo+ICsJCQlwID0gcHJpdi0+Y21kbGlzdF9ncm91cHNbcmRtYV9pZF07Cj4gKwkJ CXByZXYgPSBOVUxMOwo+ICsJCQl3aGlsZSAocCkgewo+ICsJCQkJaWYgKGNsX3RvX3NwYWNlbWl0 X3BzdGF0ZShwKS0+c3RhdGUuY3J0Y195IDwKPiArCQkJCSAgICBzcGFjZW1pdF9wc3RhdGUtPnN0 YXRlLmNydGNfeSkgewo+ICsJCQkJCXByZXYgPSBwOwo+ICsJCQkJCXAgPSBwLT5uZXh0Owo+ICsJ CQkJfSBlbHNlIHsKPiArCQkJCQlicmVhazsKPiArCQkJCX0KPiArCQkJfQo+ICsJCQlpZiAoIXBy ZXYpIHsKPiArCQkJCXByaXYtPmNtZGxpc3RfZ3JvdXBzW3JkbWFfaWRdID0gZmlyc3RfY2w7Cj4g KwkJCQlsYXN0X2NsLT5uZXh0ID0gcDsKPiArCQkJfSBlbHNlIHsKPiArCQkJCXByZXYtPm5leHQg PSBmaXJzdF9jbDsKPiArCQkJCWxhc3RfY2wtPm5leHQgPSBwOwo+ICsJCQl9Cj4gKwkJfSBlbHNl IHsKPiArCQkJcHJpdi0+Y21kbGlzdF9ncm91cHNbcmRtYV9pZF0gPSBmaXJzdF9jbDsKPiArCQl9 Cj4gKwl9Cj4gK30KPiArCj4gK3ZvaWQgY21kbGlzdF9hdG9taWNfY29tbWl0KHN0cnVjdCBkcm1f Y3J0YyAqY3J0YywKPiArCQkJICAgc3RydWN0IGRybV9jcnRjX3N0YXRlICpvbGRfc3RhdGUpCj4g K3sKWyAuLi4gXQo+ICsJZm9yIChpID0gMDsgaSA8IGh3ZGV2LT5yZG1hX251bXM7IGkrKykgewo+ ICsJCWlmIChvbGRfcmRtYXNbaV0uaW5fdXNlKQo+ICsJCQlod2Rldi0+ZW5hYmxlX2NtZGxpc3Qo YV9jcnRjLCBod2RldiwgaSwgZmFsc2UpOwo+ICsKPiArCQlpZiAoY3VyX3JkbWFzW2ldLmluX3Vz ZSkgewo+ICsJCQlkcm1fZGJnKGNydGMtPmRldiwgImNtZGxpc3QgZ3JvdXAgPSAlZFxuIiwgaSk7 Cj4gKwkJCWN1cl9jbCA9IHByaXYtPmNtZGxpc3RfZ3JvdXBzW2ldOwo+ICsJCQlmaXJzdF9jbCA9 IGN1cl9jbDsKPiArCQkJd2hpbGUgKGN1cl9jbCkgewo+ICsJCQkJaHdkZXYtPmNtZGxpc3RfZmls bF9jb25mX3JvdyhjdXJfY2wsIGh3ZGV2LAo+ICsJCQkJCUNNRExJU1RfQ01QX0lOVkFMSUQpOwo+ ICsJCQkJY21kbGlzdF9kdW1wX25vZGUoY3VyX2NsKTsKPiArCQkJCWN1cl9jbCA9IGN1cl9jbC0+ bmV4dDsKPiArCQkJfQo+ICsJCQljaHkgPSBjbF90b19zcGFjZW1pdF9wc3RhdGUoZmlyc3RfY2wp LT5zdGF0ZS5jcnRjX3k7CgpbU2V2ZXJpdHk6IEhpZ2hdCkNvdWxkIGZpcnN0X2NsIGJlIE5VTEwg aGVyZT8gSWYgY3VyX3JkbWFzW2ldLmluX3VzZSBpcyB0cnVlIGJ1dApwcml2LT5jbWRsaXN0X2dy b3Vwc1tpXSBpcyBlbXB0eSwgZmlyc3RfY2wgd291bGQgYmUgTlVMTC4gVGhpcyBjYW4gaGFwcGVu CmlmIHBsYW5lcyBhcmUgcmVtb3ZlZCBmcm9tIHRoZSBzdGF0ZSBidXQgaW5fdXNlIHdhcyBjb3Bp ZWQgYXMgdHJ1ZSBmcm9tIHRoZQpvbGQgc3RhdGUuIFRoZSBjbF90b19zcGFjZW1pdF9wc3RhdGUg bWFjcm8gd291bGQgeWllbGQgYSBuZWdhdGl2ZSBvZmZzZXQKZnJvbSBOVUxMLCByZXN1bHRpbmcg aW4gYSBjcmFzaC4KCj4gKwkJCWFkZHJsID0gKGxvd2VyXzMyX2JpdHMocHJpdi0+Y21kbGlzdF9n cm91cHNbaV0tPnBhKSAmCj4gKwkJCQkgQ01ETElTVF9BRERSTF9BTElHTl9NQVNLKSA+PiBDTURM SVNUX0FERFJMX0FMSUdOX0JJVFM7Cj4gKwo+ICsJCQlhZGRyaCA9IHVwcGVyXzMyX2JpdHMocHJp di0+Y21kbGlzdF9ncm91cHNbaV0tPnBhKTsKPiArCQkJaHdkZXYtPmNmZ19jbWRsaXN0KGh3ZGV2 LCBpLCBjaHksIGFkZHJsLCBhZGRyaCk7Cj4gKwkJCWh3ZGV2LT5lbmFibGVfY21kbGlzdChhX2Ny dGMsIGh3ZGV2LCBpLCB0cnVlKTsKPiArCQkJcHJpdi0+Y21kbGlzdF9ncm91cHNbaV0gPSBOVUxM Owo+ICsJCX0KPiArCX0KPiArfQo+ICsKWyAuLi4gXQo+ICt2b2lkIGNydGNfY21kbGlzdF9hdG9t aWNfY29tbWl0KHN0cnVjdCBzcGFjZW1pdF9jcnRjICphX2NydGMpCj4gK3sKPiArCXN0cnVjdCBj bWRsaXN0ICpjdXJfY2w7Cj4gKwlzdHJ1Y3QgZHJtX2NydGMgKmNydGMgPSAmYV9jcnRjLT5jcnRj Owo+ICsJc3RydWN0IHNwYWNlbWl0X2RybV9wcml2YXRlICpwcml2ID0gY3J0Yy0+ZGV2LT5kZXZf cHJpdmF0ZTsKPiArCXN0cnVjdCBzcGFjZW1pdF9od19kZXZpY2UgKmh3ZGV2ID0gcHJpdi0+aHdk ZXY7Cj4gKwl1OCBjcnRjX2lkID0gZHJtX2NydGNfaW5kZXgoY3J0Yyk7Cj4gKwl1OCBkZXZfaWQg PSBhX2NydGMtPmRldl9pZDsKPiArCj4gKwlkcm1fZGJnKGNydGMtPmRldiwgImNtZGxpc3QgZ3Jv dXAgPSAlZFxuIiwKPiArCQlod2Rldi0+cmRtYV9udW1zICsgY3J0Y19pZCk7Cj4gKwljdXJfY2wg PSBwcml2LT5jbWRsaXN0X2dyb3Vwc1tod2Rldi0+cmRtYV9udW1zICsgY3J0Y19pZF07Cj4gKwl3 aGlsZSAoY3VyX2NsKSB7Cj4gKwkJaHdkZXYtPmNtZGxpc3RfZmlsbF9jb25mX3JvdyhjdXJfY2ws IGh3ZGV2LCBkZXZfaWQpOwo+ICsJCWNtZGxpc3RfZHVtcF9ub2RlKGN1cl9jbCk7Cj4gKwkJY3Vy X2NsID0gY3VyX2NsLT5uZXh0Owo+ICsJfQo+ICsJaHdkZXYtPmNydGNfY21kbGlzdChjdXJfY2ws IGh3ZGV2LCBwcml2LCBjcnRjX2lkLCBkZXZfaWQpOwoKW1NldmVyaXR5OiBIaWdoXQpEb2VzIHRo aXMgcGFzcyBhIGd1YXJhbnRlZWQgTlVMTCBwb2ludGVyIHRvIHRoZSBoYXJkd2FyZSBjYWxsYmFj az8KVGhlIHdoaWxlIGxvb3AgZXhoYXVzdHMgY3VyX2NsIHRvIE5VTEwsIHdoaWNoIGlzIHRoZW4g aW1tZWRpYXRlbHkgcGFzc2VkCnRvIGh3ZGV2LT5jcnRjX2NtZGxpc3QuIEl0IGxvb2tzIGxpa2Ug dGhlIGhlYWQgb2YgdGhlIGxpc3Qgc2hvdWxkIGJlCnBhc3NlZCBpbnN0ZWFkLgoKPiArfQo+ICsK PiArLyogQ2FsbGVkIGZyb20gYXRvbWljX2NoZWNrKCksIHdoZXJlIC1FTk9NRU0gaXMgc3RpbGwg YW4gYW5zd2VyLiAqLwo+ICtpbnQgc3BhY2VtaXRfY21kbGlzdF9hbGxvYyhzdHJ1Y3QgZGV2aWNl ICpkZXYsIHN0cnVjdCBjbWRsaXN0ICpjbCkKPiArewo+ICsJaWYgKGNsLT52YSkKPiArCQlyZXR1 cm4gMDsKCltTZXZlcml0eTogQ3JpdGljYWxdCkRvZXMgcmV0dXJuaW5nIGVhcmx5IHdoZW4gY2wt PnZhIGlzIHByZXNlbnQgY2F1c2UgYWN0aXZlIGRpc3BsYXkgY29ycnVwdGlvbj8KQmVjYXVzZSBz dHJ1Y3QgY21kbGlzdCBpcyBlbWJlZGRlZCBkaXJlY3RseSBpbiB0aGUgcGxhbmUgc3RhdGUsIERS TSdzIHN0YXRlCmR1cGxpY2F0aW9uIHdpbGwgc2hhbGxvdy1jb3B5IGNsLT52YS4gSWYgYXRvbWlj X3VwZGF0ZSBtdXRhdGVzIHRoaXMgc2FtZQp2aXJ0dWFsIGFkZHJlc3Mgd2hpbGUgdGhlIGhhcmR3 YXJlIGlzIGFjdGl2ZWx5IHJlYWRpbmcgaXQgZnJvbSB0aGUgb2xkCnN0YXRlLCBpdCBjb3VsZCBs ZWFkIHRvIHNjcmVlbiB0ZWFyaW5nIG9yIERQVSBoYW5ncy4gRE1BIGJ1ZmZlcnMgZm9yCmNvbW1h bmQgbGlzdHMgZ2VuZXJhbGx5IG5lZWQgdG8gYmUgbXVsdGktYnVmZmVyZWQgb3IgYWxsb2NhdGVk IHBlci1zdGF0ZS4KCj4gKwo+ICsJY2wtPnNpemUgPSBQRVJfQ01ETElTVF9TSVpFOwo+ICsJY2wt PnZhID0gZG1hX2FsbG9jX2NvaGVyZW50KGRldiwgY2wtPnNpemUsICZjbC0+cGEsCj4gKwkJCQkg ICAgR0ZQX0tFUk5FTCB8IF9fR0ZQX1pFUk8pOwo+ICsJaWYgKCFjbC0+dmEpCj4gKwkJcmV0dXJu IC1FTk9NRU07CgpbU2V2ZXJpdHk6IE1lZGl1bV0KSXMgdGhlcmUgYSBjb3JyZXNwb25kaW5nIGRt YV9mcmVlX2NvaGVyZW50KCkgZHVyaW5nIHN0YXRlIGRlc3RydWN0aW9uPwpJZiB0aGUgYWxsb2Nh dGVkIGNsLT52YSBpcyBuZXZlciBmcmVlZCB3aGVuIHRoZSBhdG9taWMgc3RhdGUgaXMgZGVzdHJv eWVkLAp0aGlzIG1pZ2h0IGNhdXNlIGEgc3RlYWR5IGxlYWsgb2YgRE1BIG1lbW9yeS4KCj4gKwo+ ICsJcmV0dXJuIDA7Cj4gK30KWyAuLi4gXQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v c3BhY2VtaXQvc3BhY2VtaXRfZG1tdS5jIGIvZHJpdmVycy9ncHUvZHJtL3NwYWNlbWl0L3NwYWNl bWl0X2RtbXUuYwo+IGluZGV4IDAwMDAwMDAwMDAwMDAuLjJhZTMwZGQxYTRmMjMgMTAwNjQ0Cj4g LS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9zcGFjZW1pdC9zcGFjZW1pdF9k bW11LmMKWyAuLi4gXQo+ICtpbnQgc3BhY2VtaXRfZG1tdV9tYXAoc3RydWN0IGRybV9mcmFtZWJ1 ZmZlciAqZmIsIHN0cnVjdCBkcHVfbW11X3RibCAqbW11X3RibCwKPiArCQkgICAgICB1OCB0YnVf aWQsIHN0cnVjdCBjbWRsaXN0X3JlZ3MgKmNsX3JkbWEsCj4gKwkJIHN0cnVjdCBkcm1fcGxhbmUg KnBsYW5lKQo+ICt7Cj4gKwlzdHJ1Y3Qgc3BhY2VtaXRfZHJtX3ByaXZhdGUgKnByaXYgPSBmYi0+ ZGV2LT5kZXZfcHJpdmF0ZTsKPiArCXN0cnVjdCBzcGFjZW1pdF9od19kZXZpY2UgKmh3ZGV2ID0g cHJpdi0+aHdkZXY7Cj4gKwljb25zdCBzdHJ1Y3QgZHJtX2Zvcm1hdF9pbmZvICpmb3JtYXQgPSBO VUxMOwo+ICsJc3RydWN0IHNnX3RhYmxlICpzZ3QgPSBOVUxMOwo+ICsJdTMyIHRvdGFsX3NpemUs IG9mZnNldDEsIG9mZnNldDI7Cj4gKwlzdHJ1Y3QgdGJ1X2luc3RhbmNlIHRidSA9IHsgfTsKPiAr CXU4IHBsYW5lX251bTsKPiArCXUzMiB2YWw7Cj4gKwo+ICsJZm9ybWF0ID0gZmItPmZvcm1hdDsK PiArCXNndCA9IGRybV9nZW1fc2htZW1fZ2V0X3BhZ2VzX3NndCh0b19kcm1fZ2VtX3NobWVtX29i aihmYi0+b2JqWzBdKSk7CgpbU2V2ZXJpdHk6IEhpZ2hdCldpbGwgdGhpcyBzbGVlcCBpbiBhdG9t aWMgY29udGV4dD8gVGhpcyBmdW5jdGlvbiBhcHBlYXJzIHRvIGJlIGNhbGxlZApkdXJpbmcgaGFy ZHdhcmUgcHJvZ3JhbW1pbmcgaW4gdGhlIGF0b21pYyBjb21taXQgcGhhc2UuIENhbGxpbmcKZHJt X2dlbV9zaG1lbV9nZXRfcGFnZXNfc2d0IGFsbG9jYXRlcyBtZW1vcnkgYW5kIGNhbiBhY3F1aXJl IGEgbXV0ZXgsCndoaWNoIGlzIGZvcmJpZGRlbiBpbiBhdG9taWMgY29udGV4dC4gQnVmZmVyIG1h cHBpbmcgdHlwaWNhbGx5IG5lZWRzIHRvIGJlCmRlZmVycmVkIHRvIHRoZSBzbGVlcGFibGUgcHJl cGFyZV9mYiBjYWxsYmFjay4KCltTZXZlcml0eTogSGlnaF0KRG9lcyBtYXBwaW5nIG9ubHkgZmIt Pm9ialswXSBicmVhayBtdWx0aS1wbGFuYXIgZnJhbWVidWZmZXJzPyBJZiB1c2Vyc3BhY2UKcHJv dmlkZXMgYSBtdWx0aS1wbGFuYXIgZnJhbWVidWZmZXIgd2hlcmUgdGhlIHBsYW5lcyByZXNpZGUg aW4gZGlmZmVyZW50IEdFTQpvYmplY3RzLCBleHRyYWN0aW5nIHRoZSBTRyB0YWJsZSBvbmx5IGZv ciBvYmpbMF0gd2lsbCByZXN1bHQgaW4gaW5jb3JyZWN0CnBoeXNpY2FsIG1lbW9yeSBwYWdlcyBm b3IgdGhlIHNlY29uZGFyeSBwbGFuZXMuCgo+ICsJaWYgKElTX0VSUihzZ3QpKQo+ICsJCXJldHVy biBQVFJfRVJSKHNndCk7Cj4gKwo+ICsJcGxhbmVfbnVtID0gZm9ybWF0LT5udW1fcGxhbmVzOwo+ ICsKPiArCXRvdGFsX3NpemUgPSByb3VuZHVwKGZiLT5vYmpbMF0tPnNpemUsIFBBR0VfU0laRSk7 Cj4gKwo+ICsJb2Zmc2V0MSA9IHBsYW5lX251bSA+IDEgPyBmYi0+b2Zmc2V0c1sxXSA6IHRvdGFs X3NpemU7Cj4gKwlvZmZzZXQyID0gcGxhbmVfbnVtID4gMiA/IGZiLT5vZmZzZXRzWzJdIDogdG90 YWxfc2l6ZTsKPiArCj4gKwlzd2l0Y2ggKHBsYW5lX251bSkgewo+ICsJY2FzZSAzOgo+ICsJCXRi dS50dGJfcGFbMl0gPSBtbXVfdGJsLT5wYSArIChvZmZzZXQyID4+IFBBR0VfU0hJRlQpICogNDsK PiArCQl0YnUudGJ1X3ZhWzJdID0gVEJVX0JBU0VfVkEodGJ1X2lkKSArIG9mZnNldDI7CgpbU2V2 ZXJpdHk6IE1lZGl1bV0KQ291bGQgYWRkaW5nIG9mZnNldDIgZGlyZWN0bHkgdG8gVEJVX0JBU0Vf VkEgcmVzdWx0IGluIHVuYWxpZ25lZCBiYXNlCnZpcnR1YWwgYWRkcmVzc2VzPyBJZiB1c2Vyc3Bh Y2Ugc3VwcGxpZXMgYW4gb2Zmc2V0IHRoYXQgaXMgbm90IGEgbXVsdGlwbGUKb2YgUEFHRV9TSVpF LCBwcm9ncmFtbWluZyBhbiB1bmFsaWduZWQgdmlydHVhbCBhZGRyZXNzIG1pZ2h0IGNvbmZ1c2Ug dGhlCmhhcmR3YXJlIE1NVS4KCj4gKwkJdGJ1LnR0Yl9zaXplWzJdID0gUEFHRV9BTElHTih0b3Rh bF9zaXplIC0gcm91bmRkb3duKG9mZnNldDIsIFBBR0VfU0laRSkpCj4gKwkJCQkgID4+IFBBR0Vf U0hJRlQ7CgpbU2V2ZXJpdHk6IENyaXRpY2FsXQpDYW4gdGhpcyBzaXplIGNhbGN1bGF0aW9uIHVu ZGVyZmxvdz8gSWYgYSBtYWxpY2lvdXMgdXNlcnNwYWNlIGNsaWVudApwcm92aWRlcyBvZmZzZXQy IHNtYWxsZXIgdGhhbiBvZmZzZXQxLCB0aGUgdW5zaWduZWQgc3VidHJhY3Rpb24Kb2Zmc2V0MiAt IHJvdW5kZG93bihvZmZzZXQxLCBQQUdFX1NJWkUpIHdpbGwgdW5kZXJmbG93IHRvIGEgbWFzc2l2 ZQpwb3NpdGl2ZSB2YWx1ZS4gVGhpcyBjb3VsZCBwcm9ncmFtIHRoZSBETU1VIHdpdGggYSBodWdl IHRyYW5zbGF0aW9uIGJsb2NrLAphbGxvd2luZyBhcmJpdHJhcnkgb3V0LW9mLWJvdW5kcyBwaHlz aWNhbCBtZW1vcnkgcmVhZHMuCgo+ICsJCWZhbGx0aHJvdWdoOwo+ICsJY2FzZSAyOgo+ICsJCXRi dS50dGJfcGFbMV0gPSBtbXVfdGJsLT5wYSArIChvZmZzZXQxID4+IFBBR0VfU0hJRlQpICogNDsK PiArCQl0YnUudGJ1X3ZhWzFdID0gVEJVX0JBU0VfVkEodGJ1X2lkKSArIG9mZnNldDE7Cj4gKwkJ dGJ1LnR0Yl9zaXplWzFdID0gUEFHRV9BTElHTihvZmZzZXQyIC0gcm91bmRkb3duKG9mZnNldDEs IFBBR0VfU0laRSkpID4+IFBBR0VfU0hJRlQ7Cj4gKwkJZmFsbHRocm91Z2g7Cj4gKwljYXNlIDE6 Cj4gKwkJdGJ1LnR0Yl9wYVswXSA9IG1tdV90YmwtPnBhOwo+ICsJCXRidS50YnVfdmFbMF0gPSBU QlVfQkFTRV9WQSh0YnVfaWQpOwo+ICsJCXRidS50dGJfc2l6ZVswXSA9IFBBR0VfQUxJR04ob2Zm c2V0MSkgPj4gUEFHRV9TSElGVDsKPiArCQlmYWxsdGhyb3VnaDsKPiArCWRlZmF1bHQ6Cj4gKwkJ YnJlYWs7Cj4gKwl9ClsgLi4uIF0KCi0tIApTYXNoaWtvIEFJIHJldmlldyDCtyBodHRwczovL3Nh c2hpa28uZGV2LyMvcGF0Y2hzZXQvMjAyNjA3MjUtazMtZGlzcGxheS12MS0wLTZkZTM0ZDgwZTg2 Y0BnbWFpbC5jb20/cGFydD04CgotLSAKbGludXgtcGh5IG1haWxpbmcgbGlzdApsaW51eC1waHlA bGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwczovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9s aXN0aW5mby9saW51eC1waHkK