From mboxrd@z Thu Jan 1 00:00:00 1970 Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.remote-ip=100.103.45.18 ARC-Seal: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; cv=none; t=1792662394; b=oSOR7X/zZEn/L5gDN6I1oZKvICUGWosUE3BuA5aUvDtlzFXs65ou2gl4EzWctCNfdP7f T4/z1NaA045jrimelfPpkWc3ZQ3svg9u8WeXkoCctsMr3i/9N8YXAFy2JvK9YFVqqAxrm p8L88Bm9j+IC2VKAVZ5n9E9yO6iQ2Emsr1KuOM/LwM9wmQnOo9wOVz9b8zY1Dix0j+BWF Jjcj0g96VaYVzDzAnij+5+kVHIovOKXJ8m0z6HeBYuYxK1sJyPE/jk1NMtc6hjafIbad9 PHaZD48KFoMGCRXmhRqmXOOOobS6BZ+A2WxHMSEsIR/tBDr/ahpf2hjdIOhPP//6rTA== ARC-Message-Signature: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; c=relaxed/relaxed; t=1792662394; h=Received:DKIM-Signature:Message-ID:From:Subject:Reply-To:To:Cc: In-Reply-To:References:Content-Type:Content-Transfer-Encoding:Date; bh=JBtY2REbjZJlCm+wUUQG7qb/B+U8mdvcqm/HFY1lIp0=; b=vdxQ9WyOvbmTPqP2zznEMbzR+7CjU6I4dSd+yUES8AY5+kKqrk5rv0REUoxVHBxsnLRP 6w0PqXnmyUXizSm1PKne1BOSskr3eUQWURKQ+Jq/CDt99h+9pBsWSRfn0lJ4X1RFlshzm sE8dZAtPjeXTGAdvbi0kzTihtwPyQL/qpIr+uG5T1ZzLvJlPn2GiosC3mE6Qd8Mmn1ROa OQMqny0c8TB6kr6Dc5ils+GXwIYHJ6FCgpGWLVIdGW00CxLfUbXNUPKAOsOf4eL7PgT+X YKovJR0sImv6XxD4D+h8C4IMIoFFUoExtZgZ27hVkuxbwMXkHu4wIxj6zxvBO+uHOug== ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=hm9AyA4Z; arc=none smtp.remote-ip=100.103.45.18 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (prime256v1)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8992D606A31A for ; Thu, 22 Oct 2026 09:46:34 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key, unprotected) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=hm9AyA4Z Received: by smtp.kernel.org (Postfix) with ESMTPSA id B49711F000C1; Thu, 22 Oct 2026 09:46:33 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1792662394; bh=JBtY2REbjZJlCm+wUUQG7qb/B+U8mdvcqm/HFY1lIp0=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=hm9AyA4ZnFy7ox6UertvxgxIUwLEq8gR3CSfsDxj7Qtnvgd51evvSIHli2wqcRcWb xskt54rS/4WkOsIJxf8UTqusmUGsCyUFbx4L9pvZ+MKLnvRfynS/Kfkzvcis0aOPoh lA/4v2S1NpYvgLxwLHzoHpJ+3p2HVa8rVMTTBfKOKIj/lYZjr6nKbxe0gfPqym/WAf H5NXiO9AMu6fFkHOfVw9pTFvNYTR3nwH8PcliGQfW5DmTQkEG2/LaYip14uE0js70G 3yUk58FfETZFDI6UiSOOoQSFYJfQyKJasfQtJ0wTIkyxXhXe8p+twVeUA7WlJls+x4 K2TgR3lyiPkBw== Message-ID: From: sashiko-bot@kernel.org Subject: Re: [PATCH v2 2/2] i2c: amlogic: Add Amlogic A9 I2C controller driver Reply-To: sashiko-reviews@lists.linux.dev To: "Xianwei Zhao" Cc: linux-amlogic@lists.infradead.org, devicetree@vger.kernel.org, robh@kernel.org, conor+dt@kernel.org, neil.armstrong@linaro.org In-Reply-To: <20261022-a9-i2c-v2-2-45e3cef175bf@amlogic.com> References: <20261022-a9-i2c-v2-0-45e3cef175bf@amlogic.com> <20261022-a9-i2c-v2-2-45e3cef175bf@amlogic.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Date: Thu, 22 Oct 2026 09:46:33 +0000 X-Mailing-List: devicetree@vger.kernel.org List-Id: List-Post: List-Help: List-Subscribe: List-Unsubscribe: List-Owner: Precedence: list Thank you for your contribution! Sashiko AI review found 5 potential issue(= s) to consider: - [High] i2c: amlogic-a9: unlocked state init and late IRQ setup in aml_i2c= _do_start() - [High] i2c: amlogic-a9: threshold IRQs left enabled on timeout in aml_i2c= _xfer_msg() - [High] i2c: amlogic-a9: unhandled IRQ and spurious complete() in aml_i2c_= irq() - [High] i2c: amlogic: missing RX drain in aml_i2c_irq() when A9_PHY_DONE i= s set - [Medium] i2c: amlogic-a9: unmasked msg->addr in aml_i2c_do_start() corrup= ts START_LEN -- commit 10e276126f680fbcf2e402bbde459a690540ef33 Author: Junyi Zhao i2c: amlogic: Add Amlogic A9 I2C controller driver This commit adds a driver for the I2C controller found on Amlogic A9 SoCs, along with the corresponding Kconfig, Makefile, and MAINTAINERS entries. > diff --git a/drivers/i2c/busses/i2c-amlogic-a9.c b/drivers/i2c/busses/i2c= -amlogic-a9.c > new file mode 100644 > index 0000000000000..d4954a4fd88ef > --- /dev/null > +++ b/drivers/i2c/busses/i2c-amlogic-a9.c > @@ -0,0 +1,469 @@ [ ... ] > +static irqreturn_t aml_i2c_irq(int irqno, void *dev_id) > +{ > + struct aml_i2c *i2c =3D dev_id; > + u8 *buf =3D NULL; > + int ret; > + u32 rd_len, i; > + u32 rd_val; > + > + spin_lock(&i2c->lock); > + ret =3D controller_is_error(i2c); > + if (ret) { > + i2c->error =3D ret; > + goto complete_irq_out; > + } > + > + switch (i2c->state) { > + case A9_STATE_READ: > + buf =3D i2c->msg->buf; > + rd_len =3D min(i2c->msg->len - i2c->pos, A9_I2C_FIFO_DEPTH); > + for (i =3D 0; i < rd_len; i++) { > + rd_val =3D readl(i2c->regs + REG_CFG_RX); > + buf[i2c->pos++] =3D rd_val & TX_RX_DATA; > + } > + /* Rx must clear thresh after read fifo */ > + clear_irq_status(i2c, A9_RX_THRESH_READ); > + break; > + case A9_STATE_WRITE: > + aml_i2c_prepare_xfer(i2c, A9_FIFO_FILL_HALF); > + if ((i2c->pos + A9_I2C_HALF_FIFO) >=3D i2c->msg->len) > + aml_i2c_set_mask(i2c, REG_CFG_IRQ_ENABLE, A9_TX_THRESH_WRITE, 0); > + i2c->pos +=3D i2c->count; > + /* Tx must clear thresh after write fifo */ > + clear_irq_status(i2c, A9_TX_THRESH_WRITE); > + break; > + case A9_STATE_IDLE: > + dev_warn(i2c->dev, "i2c irq triggered abnormally, irq_state:0x%x,irq_e= n:0x%x\n", > + readl(i2c->regs + REG_CFG_IRQ_STATE), > + readl(i2c->regs + REG_CFG_IRQ_ENABLE)); > + break; > + default: > + break; > + } > + > + if (!controller_is_done(i2c)) { > + goto irq_trans_out; > + } else { > + if (i2c->state =3D=3D A9_STATE_READ && (i2c->msg->len - i2c->pos)) > + goto irq_trans_out; > + } [Severity: High] Can a multi-chunk read (msg->len > A9_I2C_FIFO_DEPTH) hang in drivers/i2c/busses/i2c-amlogic-a9.c:aml_i2c_irq() if the remaining bytes finish arriving before A9_RX_THRESH_READ is cleared? In aml_i2c_xfer() -> aml_i2c_xfer_msg() -> aml_i2c_do_start(), a read with msg->len > 32 enables A9_RX_THRESH_READ alongside A9_PHY_DONE, with I2C_RX_THR configured to 32. When the first 32 bytes arrive, A9_RX_THRESH_R= EAD asserts. If interrupt handling is slightly delayed or the remaining tail by= tes finish arriving while the A9_STATE_READ loop is reading the first 32 bytes from REG_CFG_RX, A9_PHY_DONE will already be set in REG_CFG_IRQ_STATE before clear_irq_status(i2c, A9_RX_THRESH_READ) runs. Because A9_STATE_READ only drains up to A9_I2C_FIFO_DEPTH bytes per call, i2c->msg->len - i2c->pos remains non-zero, and the controller_is_done(i2c) branch takes goto irq_trans_out without draining the remaining tail bytes or completing i2c->done. Since A9_PHY_DONE is already asserted and fewer than = 32 bytes remain to re-trigger A9_RX_THRESH_READ, no new rising edge will occur= on the interrupt line, leaving wait_for_completion_timeout() in aml_i2c_xfer_msg() to time out with -ETIMEDOUT. Should aml_i2c_irq() drain the remaining bytes in the RX FIFO when controller_is_done(i2c) is true during A9_STATE_READ before completing the transfer? > + > +complete_irq_out: > + reset_fifo_pos(i2c); > + complete(&i2c->done); > + i2c->state =3D A9_STATE_IDLE; > + aml_i2c_set_mask(i2c, REG_CFG_IRQ_ENABLE, A9_RX_THRESH_READ | A9_TX_THR= ESH_WRITE, 0); > + clear_irq_status(i2c, IRQ_ALL_MASK); > +irq_trans_out: > + spin_unlock(&i2c->lock); > + > + return IRQ_HANDLED; > +} [Severity: High] What happens in drivers/i2c/busses/i2c-amlogic-a9.c:aml_i2c_irq() when an interrupt arrives while i2c->state is A9_STATE_IDLE? First, controller_is_error(i2c) is checked before inspecting i2c->state. If= a late A9_NCK_ERROR interrupt fires after a transfer has already timed out and transitioned to A9_STATE_IDLE, aml_i2c_irq() sets i2c->error =3D -ENXIO, ju= mps to complete_irq_out, and calls complete(&i2c->done). Second, in the switch statement, the A9_STATE_IDLE case logs a warning and breaks into the completion checks: if (!controller_is_done(i2c)) { goto irq_trans_out; } If a threshold interrupt fires while in A9_STATE_IDLE and controller_is_don= e() is false, aml_i2c_irq() jumps to irq_trans_out and returns IRQ_HANDLED with= out clearing REG_CFG_IRQ_STATE or masking the threshold interrupt in REG_CFG_IRQ_ENABLE, leaving the interrupt asserted. Conversely, if controller_is_done() is true (such as a late A9_PHY_DONE), execution falls through to complete_irq_out and spuriously signals i2c->done while idle. Should aml_i2c_irq() check for A9_STATE_IDLE up front, disable threshold interrupts, clear REG_CFG_IRQ_STATE, and return without calling complete(&i2c->done)? > + > +static void aml_i2c_do_start(struct aml_i2c *i2c, struct i2c_msg *msg) > +{ > + unsigned int reg_val; > + unsigned int trans_len; > + > + trans_len =3D msg->len; > + reg_val =3D (unsigned int)((msg->addr << START_SADDR_SHIFT) | > + ((msg->flags & I2C_M_RD) ? START_READ : 0) | > + ((trans_len & 0xfff) << START_LEN_SHIFT) | START_START); > + aml_i2c_set_mask(i2c, REG_CFG_START, > + START_START | START_SLAVE_ADDR | START_READ | START_LEN, reg_val); [Severity: Medium] In drivers/i2c/busses/i2c-amlogic-a9.c:aml_i2c_do_start(), could upper bits= in msg->addr corrupt the START_LEN field of REG_CFG_START? When userspace submits an I2C_RDWR ioctl on /dev/i2c-*, msg->addr is a u16 passed through i2cdev_ioctl_rdwr() -> i2c_transfer() -> aml_i2c_xfer() -> aml_i2c_xfer_msg() -> aml_i2c_do_start() without masking. Because msg->addr << START_SADDR_SHIFT is not masked to 7 bits (or START_SLAVE_ADDR) before being ORed with (trans_len & 0xfff) << START_LEN_SHIFT and written v= ia aml_i2c_set_mask() under the combined mask START_START | START_SLAVE_ADDR | START_READ | START_LEN, any bits set in msg->addr[15:11] shift into START_LEN (GENMASK(23, 12)) and alter the hardware transfer length. Should msg->addr be masked (for example with 0x7f, since 10-bit addressing = is not advertised in aml_i2c_func()) before shifting by START_SADDR_SHIFT? > + clear_irq_status(i2c, IRQ_ALL_MASK); > + /* enable thresh mode */ > + if (trans_len > A9_I2C_FIFO_DEPTH) { > + reg_val =3D (msg->flags & I2C_M_RD) ? A9_RX_THRESH_READ : A9_TX_THRESH= _WRITE; > + aml_i2c_set_mask(i2c, REG_CFG_IRQ_ENABLE, > + A9_RX_THRESH_READ | A9_TX_THRESH_WRITE, reg_val); > + } > +} > + > +static int aml_i2c_xfer_msg(struct aml_i2c *i2c, struct i2c_msg *msg, bo= ol last) > +{ > + unsigned long time_left, flags; > + int ret =3D 0; > + > + i2c->msg =3D msg; > + i2c->pos =3D 0; > + i2c->count =3D 0; > + i2c->error =3D 0; > + > + i2c->state =3D (msg->flags & I2C_M_RD) ? A9_STATE_READ : A9_STATE_WRITE; > + spin_lock_irqsave(&i2c->lock, flags); > + aml_i2c_prepare_xfer(i2c, A9_FIFO_FILL_FULL); > + i2c->pos +=3D i2c->count; > + spin_unlock_irqrestore(&i2c->lock, flags); > + reinit_completion(&i2c->done); > + > + if (last) > + aml_i2c_set_mask(i2c, REG_CFG_BUS, BUS_NO_STOP, 0); > + else > + aml_i2c_set_mask(i2c, REG_CFG_BUS, BUS_NO_STOP, BUS_NO_STOP); > + /* Start the transfer */ > + aml_i2c_do_start(i2c, msg); [Severity: High] Can starting the hardware transfer before clearing IRQ status and enabling threshold interrupts in drivers/i2c/busses/i2c-amlogic-a9.c:aml_i2c_do_star= t(), without holding i2c->lock across transfer setup in aml_i2c_xfer_msg(), race with aml_i2c_irq()? In aml_i2c_do_start(), setting START_START in REG_CFG_START kicks off the hardware transaction before clear_irq_status(i2c, IRQ_ALL_MASK) and before enabling A9_RX_THRESH_READ or A9_TX_THRESH_WRITE in REG_CFG_IRQ_ENABLE: aml_i2c_set_mask(i2c, REG_CFG_START, START_START | START_SLAVE_ADDR | START_READ | START_LEN, reg_val); clear_irq_status(i2c, IRQ_ALL_MASK); /* enable thresh mode */ if (trans_len > A9_I2C_FIFO_DEPTH) { reg_val =3D (msg->flags & I2C_M_RD) ? A9_RX_THRESH_READ : A9_TX_THRESH_WR= ITE; aml_i2c_set_mask(i2c, REG_CFG_IRQ_ENABLE, A9_RX_THRESH_READ | A9_TX_THRESH_WRITE, reg_val); } If the task is preempted or interrupted after writing REG_CFG_START, or if = the controller quickly asserts A9_NCK_ERROR (such as on an address NACK) or A9_PHY_DONE before clear_irq_status() runs, clear_irq_status(i2c, IRQ_ALL_M= ASK) can wipe out the newly asserted IRQ status bits and cause wait_for_completion_timeout() to time out. Similarly, if aml_i2c_irq() runs and completes on an early NACK before aml_i2c_do_start() updates REG_CFG_IRQ_ENABLE, the unlocked read-modify-write in aml_i2c_do_start() can re-enable A9_RX_THRESH_READ or A9_TX_THRESH_WRITE after complete_irq_out already cleared them. In addition, in aml_i2c_xfer_msg(), i2c->msg, i2c->pos, i2c->count, i2c->error, and i2c->state are initialized outside i2c->lock, and i2c->lock= is released before reinit_completion(&i2c->done), REG_CFG_BUS configuration, a= nd aml_i2c_do_start(). If a late interrupt from a previous timed-out transfer arrives while i2c->state is already set to A9_STATE_READ or A9_STATE_WRITE, aml_i2c_irq() can modify i2c->pos and access the new i2c->msg->buf before t= he new transfer begins (and if i2c->pos exceeds the new msg->len in A9_STATE_READ, the signed subtraction i2c->msg->len - i2c->pos in min(i2c->msg->len - i2c->pos, A9_I2C_FIFO_DEPTH) will wrap to a large u32 in rd_len and overflow buf[i2c->pos++]). Could the state initialization, reinit_completion(), bus configuration, IRQ status clearing, threshold IRQ setup, and START_START trigger all be perfor= med under a single spin_lock_irqsave(&i2c->lock, flags) critical section, with clear_irq_status() and REG_CFG_IRQ_ENABLE configured before asserting START_START? > + > + time_left =3D msecs_to_jiffies(I2C_TIMEOUT_MS); > + time_left =3D wait_for_completion_timeout(&i2c->done, time_left); > + > + /* > + * Protect access to i2c struct and registers from interrupt > + * handlers triggered by a transfer terminated after the > + * timeout period > + */ > + > + spin_lock_irqsave(&i2c->lock, flags); > + if (!time_left) { > + i2c->state =3D A9_STATE_IDLE; > + clear_irq_status(i2c, IRQ_ALL_MASK); > + reset_fifo_pos(i2c); > + ret =3D -ETIMEDOUT; > + } [Severity: High] When a transfer with msg->len > A9_I2C_FIFO_DEPTH times out in drivers/i2c/busses/i2c-amlogic-a9.c:aml_i2c_xfer_msg(), aren't the threshold interrupts in REG_CFG_IRQ_ENABLE and the active transfer in REG_CFG_START l= eft enabled? In aml_i2c_do_start(), transfers with trans_len > A9_I2C_FIFO_DEPTH enable A9_RX_THRESH_READ or A9_TX_THRESH_WRITE in REG_CFG_IRQ_ENABLE, and only update REG_CFG_IRQ_ENABLE when trans_len > A9_I2C_FIFO_DEPTH. On normal completion in aml_i2c_irq(), complete_irq_out clears A9_RX_THRESH_READ | A9_TX_THRESH_WRITE in REG_CFG_IRQ_ENABLE, but the !time_left timeout path in aml_i2c_xfer_msg() does not disable those threshold IRQ bits or stop the transfer in REG_CFG_START. If a >32-byte write times out and the next transfer is a short read with msg->len <=3D 32, wouldn't A9_TX_THRESH_WRITE remain enabled and fire during A9_STATE_READ, causing aml_i2c_irq() to read from an empty REG_CFG_RX FIFO into msg->buf? [ ... ] > +MODULE_DESCRIPTION("Amlogic I2C Bus driver"); > +MODULE_AUTHOR("Junyi Zhao "); > +MODULE_LICENSE("GPL"); --=20 Sashiko AI review =C2=B7 https://sashiko.dev/#/patchset/20261022-a9-i2c-v2-= 0-45e3cef175bf@amlogic.com?part=3D2 From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (prime256v1) server-digest SHA256) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 90CCD606A319 for ; Thu, 22 Oct 2026 09:46:37 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key, unprotected) header.d=lists.infradead.org header.i=@lists.infradead.org header.a=rsa-sha256 header.s=bombadil.20210309 header.b=DRI3Jwdb; dkim=fail reason="signature verification failed" (2048-bit key, unprotected) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=hm9AyA4Z 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:Date:References: In-Reply-To:Cc:To:Subject:From:Message-ID:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Unsubscribe-Post:List-Owner; bh=cQz+AfV3op8A7GCEpCY4o8QtZHaeBwTawWHZPV6/zHg=; b=DRI3JwdbYCVmI6lJobV9GAuoO9 WKgvvcjlNw9e3RUWKDSLqUO/XjFZKar0BQwyKqBBIiMyRld02ha8csQVWWsRToBRPCqlx0ujOPkor 6AEyYDHMxUf5lSBUIf7z6G7EVsOokgPovgheWAABjKZZMz3Fi/dZ5w+oB/PgZFzpmBKIiF34tKYh6 jajiH5eNmhJSEri6v6iWGIRIAWbTiTjkCZvBgsPLXSbWSlGkcdt6aQzvj13VWcp8BW8QN5WFV7JVD 6q090QWOmg6TkK4z5Hk6gLjUvn1Qzhg/EQZqfH/UEGzZNGwB/u4dfJ1BwihtI4ZKY20HWOIwN5S/w 2kkRTzZw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.100.1 #2 (Red Hat Linux)) id 1xJpNc-0000000Ds2e-0V0o; Thu, 22 Oct 2026 09:46:36 +0000 Received: from sea.source.kernel.org ([2600:3c0a:e001:78e:0:1991:8:25]) by bombadil.infradead.org with esmtps (Exim 4.100.1 #2 (Red Hat Linux)) id 1xJpNa-0000000Ds2P-3aEO for linux-amlogic@lists.infradead.org; Thu, 22 Oct 2026 09:46:34 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id 3E87943A0D; Thu, 22 Oct 2026 09:46:34 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id B49711F000C1; Thu, 22 Oct 2026 09:46:33 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1792662394; bh=JBtY2REbjZJlCm+wUUQG7qb/B+U8mdvcqm/HFY1lIp0=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=hm9AyA4ZnFy7ox6UertvxgxIUwLEq8gR3CSfsDxj7Qtnvgd51evvSIHli2wqcRcWb xskt54rS/4WkOsIJxf8UTqusmUGsCyUFbx4L9pvZ+MKLnvRfynS/Kfkzvcis0aOPoh lA/4v2S1NpYvgLxwLHzoHpJ+3p2HVa8rVMTTBfKOKIj/lYZjr6nKbxe0gfPqym/WAf H5NXiO9AMu6fFkHOfVw9pTFvNYTR3nwH8PcliGQfW5DmTQkEG2/LaYip14uE0js70G 3yUk58FfETZFDI6UiSOOoQSFYJfQyKJasfQtJ0wTIkyxXhXe8p+twVeUA7WlJls+x4 K2TgR3lyiPkBw== Message-ID: From: sashiko-bot@kernel.org Subject: Re: [PATCH v2 2/2] i2c: amlogic: Add Amlogic A9 I2C controller driver To: "Xianwei Zhao" Cc: linux-amlogic@lists.infradead.org, devicetree@vger.kernel.org, robh@kernel.org, conor+dt@kernel.org, neil.armstrong@linaro.org In-Reply-To: <20261022-a9-i2c-v2-2-45e3cef175bf@amlogic.com> References: <20261022-a9-i2c-v2-0-45e3cef175bf@amlogic.com> <20261022-a9-i2c-v2-2-45e3cef175bf@amlogic.com> Date: Thu, 22 Oct 2026 09:46:33 +0000 X-BeenThere: linux-amlogic@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: sashiko-reviews@lists.linux.dev X-Archived-By: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-amlogic" X-Spam-Status: No, score=-8.9 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_EF,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=4.0.1 X-Spam-Checker-Version: SpamAssassin 4.0.1 (2024-03-26) on aws-us-west-2-korg-listserv-alma10-1 VGhhbmsgeW91IGZvciB5b3VyIGNvbnRyaWJ1dGlvbiEgU2FzaGlrbyBBSSByZXZpZXcgZm91bmQg NSBwb3RlbnRpYWwgaXNzdWUocykgdG8gY29uc2lkZXI6Ci0gW0hpZ2hdIGkyYzogYW1sb2dpYy1h OTogdW5sb2NrZWQgc3RhdGUgaW5pdCBhbmQgbGF0ZSBJUlEgc2V0dXAgaW4gYW1sX2kyY19kb19z dGFydCgpCi0gW0hpZ2hdIGkyYzogYW1sb2dpYy1hOTogdGhyZXNob2xkIElSUXMgbGVmdCBlbmFi bGVkIG9uIHRpbWVvdXQgaW4gYW1sX2kyY194ZmVyX21zZygpCi0gW0hpZ2hdIGkyYzogYW1sb2dp Yy1hOTogdW5oYW5kbGVkIElSUSBhbmQgc3B1cmlvdXMgY29tcGxldGUoKSBpbiBhbWxfaTJjX2ly cSgpCi0gW0hpZ2hdIGkyYzogYW1sb2dpYzogbWlzc2luZyBSWCBkcmFpbiBpbiBhbWxfaTJjX2ly cSgpIHdoZW4gQTlfUEhZX0RPTkUgaXMgc2V0Ci0gW01lZGl1bV0gaTJjOiBhbWxvZ2ljLWE5OiB1 bm1hc2tlZCBtc2ctPmFkZHIgaW4gYW1sX2kyY19kb19zdGFydCgpIGNvcnJ1cHRzIFNUQVJUX0xF TgotLQoKY29tbWl0IDEwZTI3NjEyNmY2ODBmYmNmMmU0MDJiYmRlNDU5YTY5MDU0MGVmMzMKQXV0 aG9yOiBKdW55aSBaaGFvIDxqdW55aS56aGFvQGFtbG9naWMuY29tPgoKaTJjOiBhbWxvZ2ljOiBB ZGQgQW1sb2dpYyBBOSBJMkMgY29udHJvbGxlciBkcml2ZXIKClRoaXMgY29tbWl0IGFkZHMgYSBk cml2ZXIgZm9yIHRoZSBJMkMgY29udHJvbGxlciBmb3VuZCBvbiBBbWxvZ2ljIEE5IFNvQ3MsCmFs b25nIHdpdGggdGhlIGNvcnJlc3BvbmRpbmcgS2NvbmZpZywgTWFrZWZpbGUsIGFuZCBNQUlOVEFJ TkVSUyBlbnRyaWVzLgoKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9pMmMvYnVzc2VzL2kyYy1hbWxv Z2ljLWE5LmMgYi9kcml2ZXJzL2kyYy9idXNzZXMvaTJjLWFtbG9naWMtYTkuYwo+IG5ldyBmaWxl IG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAwMDAwMC4uZDQ5NTRhNGZkODhlZgo+IC0tLSAv ZGV2L251bGwKPiArKysgYi9kcml2ZXJzL2kyYy9idXNzZXMvaTJjLWFtbG9naWMtYTkuYwo+IEBA IC0wLDAgKzEsNDY5IEBACgpbIC4uLiBdCgo+ICtzdGF0aWMgaXJxcmV0dXJuX3QgYW1sX2kyY19p cnEoaW50IGlycW5vLCB2b2lkICpkZXZfaWQpCj4gK3sKPiArCXN0cnVjdCBhbWxfaTJjICppMmMg PSBkZXZfaWQ7Cj4gKwl1OCAqYnVmID0gTlVMTDsKPiArCWludCByZXQ7Cj4gKwl1MzIgcmRfbGVu LCBpOwo+ICsJdTMyIHJkX3ZhbDsKPiArCj4gKwlzcGluX2xvY2soJmkyYy0+bG9jayk7Cj4gKwly ZXQgPSBjb250cm9sbGVyX2lzX2Vycm9yKGkyYyk7Cj4gKwlpZiAocmV0KSB7Cj4gKwkJaTJjLT5l cnJvciA9IHJldDsKPiArCQlnb3RvIGNvbXBsZXRlX2lycV9vdXQ7Cj4gKwl9Cj4gKwo+ICsJc3dp dGNoIChpMmMtPnN0YXRlKSB7Cj4gKwljYXNlIEE5X1NUQVRFX1JFQUQ6Cj4gKwkJYnVmID0gaTJj LT5tc2ctPmJ1ZjsKPiArCQlyZF9sZW4gPSBtaW4oaTJjLT5tc2ctPmxlbiAtIGkyYy0+cG9zLCBB OV9JMkNfRklGT19ERVBUSCk7Cj4gKwkJZm9yIChpID0gMDsgaSA8IHJkX2xlbjsgaSsrKSB7Cj4g KwkJCXJkX3ZhbCA9IHJlYWRsKGkyYy0+cmVncyArIFJFR19DRkdfUlgpOwo+ICsJCQlidWZbaTJj LT5wb3MrK10gPSByZF92YWwgJiBUWF9SWF9EQVRBOwo+ICsJCX0KPiArCQkvKiBSeCBtdXN0IGNs ZWFyIHRocmVzaCBhZnRlciByZWFkIGZpZm8gKi8KPiArCQljbGVhcl9pcnFfc3RhdHVzKGkyYywg QTlfUlhfVEhSRVNIX1JFQUQpOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSBBOV9TVEFURV9XUklURToK PiArCQlhbWxfaTJjX3ByZXBhcmVfeGZlcihpMmMsIEE5X0ZJRk9fRklMTF9IQUxGKTsKPiArCQlp ZiAoKGkyYy0+cG9zICsgQTlfSTJDX0hBTEZfRklGTykgPj0gaTJjLT5tc2ctPmxlbikKPiArCQkJ YW1sX2kyY19zZXRfbWFzayhpMmMsIFJFR19DRkdfSVJRX0VOQUJMRSwgQTlfVFhfVEhSRVNIX1dS SVRFLCAwKTsKPiArCQlpMmMtPnBvcyArPSBpMmMtPmNvdW50Owo+ICsJCS8qIFR4IG11c3QgY2xl YXIgdGhyZXNoIGFmdGVyIHdyaXRlIGZpZm8gKi8KPiArCQljbGVhcl9pcnFfc3RhdHVzKGkyYywg QTlfVFhfVEhSRVNIX1dSSVRFKTsKPiArCQlicmVhazsKPiArCWNhc2UgQTlfU1RBVEVfSURMRToK PiArCQlkZXZfd2FybihpMmMtPmRldiwgImkyYyBpcnEgdHJpZ2dlcmVkIGFibm9ybWFsbHksIGly cV9zdGF0ZToweCV4LGlycV9lbjoweCV4XG4iLAo+ICsJCQkgcmVhZGwoaTJjLT5yZWdzICsgUkVH X0NGR19JUlFfU1RBVEUpLAo+ICsJCQkgcmVhZGwoaTJjLT5yZWdzICsgUkVHX0NGR19JUlFfRU5B QkxFKSk7Cj4gKwkJYnJlYWs7Cj4gKwlkZWZhdWx0Ogo+ICsJCWJyZWFrOwo+ICsJfQo+ICsKPiAr CWlmICghY29udHJvbGxlcl9pc19kb25lKGkyYykpIHsKPiArCQlnb3RvIGlycV90cmFuc19vdXQ7 Cj4gKwl9IGVsc2Ugewo+ICsJCWlmIChpMmMtPnN0YXRlID09IEE5X1NUQVRFX1JFQUQgJiYgKGky Yy0+bXNnLT5sZW4gLSBpMmMtPnBvcykpCj4gKwkJCWdvdG8gaXJxX3RyYW5zX291dDsKPiArCX0K CltTZXZlcml0eTogSGlnaF0KQ2FuIGEgbXVsdGktY2h1bmsgcmVhZCAobXNnLT5sZW4gPiBBOV9J MkNfRklGT19ERVBUSCkgaGFuZyBpbgpkcml2ZXJzL2kyYy9idXNzZXMvaTJjLWFtbG9naWMtYTku YzphbWxfaTJjX2lycSgpIGlmIHRoZSByZW1haW5pbmcgYnl0ZXMKZmluaXNoIGFycml2aW5nIGJl Zm9yZSBBOV9SWF9USFJFU0hfUkVBRCBpcyBjbGVhcmVkPwoKSW4gYW1sX2kyY194ZmVyKCkgLT4g YW1sX2kyY194ZmVyX21zZygpIC0+IGFtbF9pMmNfZG9fc3RhcnQoKSwgYSByZWFkIHdpdGgKbXNn LT5sZW4gPiAzMiBlbmFibGVzIEE5X1JYX1RIUkVTSF9SRUFEIGFsb25nc2lkZSBBOV9QSFlfRE9O RSwgd2l0aApJMkNfUlhfVEhSIGNvbmZpZ3VyZWQgdG8gMzIuIFdoZW4gdGhlIGZpcnN0IDMyIGJ5 dGVzIGFycml2ZSwgQTlfUlhfVEhSRVNIX1JFQUQKYXNzZXJ0cy4gSWYgaW50ZXJydXB0IGhhbmRs aW5nIGlzIHNsaWdodGx5IGRlbGF5ZWQgb3IgdGhlIHJlbWFpbmluZyB0YWlsIGJ5dGVzCmZpbmlz aCBhcnJpdmluZyB3aGlsZSB0aGUgQTlfU1RBVEVfUkVBRCBsb29wIGlzIHJlYWRpbmcgdGhlIGZp cnN0IDMyIGJ5dGVzCmZyb20gUkVHX0NGR19SWCwgQTlfUEhZX0RPTkUgd2lsbCBhbHJlYWR5IGJl IHNldCBpbiBSRUdfQ0ZHX0lSUV9TVEFURSBiZWZvcmUKY2xlYXJfaXJxX3N0YXR1cyhpMmMsIEE5 X1JYX1RIUkVTSF9SRUFEKSBydW5zLgoKQmVjYXVzZSBBOV9TVEFURV9SRUFEIG9ubHkgZHJhaW5z IHVwIHRvIEE5X0kyQ19GSUZPX0RFUFRIIGJ5dGVzIHBlciBjYWxsLAppMmMtPm1zZy0+bGVuIC0g aTJjLT5wb3MgcmVtYWlucyBub24temVybywgYW5kIHRoZSBjb250cm9sbGVyX2lzX2RvbmUoaTJj KQpicmFuY2ggdGFrZXMgZ290byBpcnFfdHJhbnNfb3V0IHdpdGhvdXQgZHJhaW5pbmcgdGhlIHJl bWFpbmluZyB0YWlsIGJ5dGVzIG9yCmNvbXBsZXRpbmcgaTJjLT5kb25lLiBTaW5jZSBBOV9QSFlf RE9ORSBpcyBhbHJlYWR5IGFzc2VydGVkIGFuZCBmZXdlciB0aGFuIDMyCmJ5dGVzIHJlbWFpbiB0 byByZS10cmlnZ2VyIEE5X1JYX1RIUkVTSF9SRUFELCBubyBuZXcgcmlzaW5nIGVkZ2Ugd2lsbCBv Y2N1ciBvbgp0aGUgaW50ZXJydXB0IGxpbmUsIGxlYXZpbmcgd2FpdF9mb3JfY29tcGxldGlvbl90 aW1lb3V0KCkgaW4KYW1sX2kyY194ZmVyX21zZygpIHRvIHRpbWUgb3V0IHdpdGggLUVUSU1FRE9V VC4KClNob3VsZCBhbWxfaTJjX2lycSgpIGRyYWluIHRoZSByZW1haW5pbmcgYnl0ZXMgaW4gdGhl IFJYIEZJRk8gd2hlbgpjb250cm9sbGVyX2lzX2RvbmUoaTJjKSBpcyB0cnVlIGR1cmluZyBBOV9T VEFURV9SRUFEIGJlZm9yZSBjb21wbGV0aW5nIHRoZQp0cmFuc2Zlcj8KCj4gKwo+ICtjb21wbGV0 ZV9pcnFfb3V0Ogo+ICsJcmVzZXRfZmlmb19wb3MoaTJjKTsKPiArCWNvbXBsZXRlKCZpMmMtPmRv bmUpOwo+ICsJaTJjLT5zdGF0ZSA9IEE5X1NUQVRFX0lETEU7Cj4gKwlhbWxfaTJjX3NldF9tYXNr KGkyYywgUkVHX0NGR19JUlFfRU5BQkxFLCBBOV9SWF9USFJFU0hfUkVBRCB8IEE5X1RYX1RIUkVT SF9XUklURSwgMCk7Cj4gKwljbGVhcl9pcnFfc3RhdHVzKGkyYywgSVJRX0FMTF9NQVNLKTsKPiAr aXJxX3RyYW5zX291dDoKPiArCXNwaW5fdW5sb2NrKCZpMmMtPmxvY2spOwo+ICsKPiArCXJldHVy biBJUlFfSEFORExFRDsKPiArfQoKW1NldmVyaXR5OiBIaWdoXQpXaGF0IGhhcHBlbnMgaW4gZHJp dmVycy9pMmMvYnVzc2VzL2kyYy1hbWxvZ2ljLWE5LmM6YW1sX2kyY19pcnEoKSB3aGVuIGFuCmlu dGVycnVwdCBhcnJpdmVzIHdoaWxlIGkyYy0+c3RhdGUgaXMgQTlfU1RBVEVfSURMRT8KCkZpcnN0 LCBjb250cm9sbGVyX2lzX2Vycm9yKGkyYykgaXMgY2hlY2tlZCBiZWZvcmUgaW5zcGVjdGluZyBp MmMtPnN0YXRlLiBJZiBhCmxhdGUgQTlfTkNLX0VSUk9SIGludGVycnVwdCBmaXJlcyBhZnRlciBh IHRyYW5zZmVyIGhhcyBhbHJlYWR5IHRpbWVkIG91dCBhbmQKdHJhbnNpdGlvbmVkIHRvIEE5X1NU QVRFX0lETEUsIGFtbF9pMmNfaXJxKCkgc2V0cyBpMmMtPmVycm9yID0gLUVOWElPLCBqdW1wcwp0 byBjb21wbGV0ZV9pcnFfb3V0LCBhbmQgY2FsbHMgY29tcGxldGUoJmkyYy0+ZG9uZSkuCgpTZWNv bmQsIGluIHRoZSBzd2l0Y2ggc3RhdGVtZW50LCB0aGUgQTlfU1RBVEVfSURMRSBjYXNlIGxvZ3Mg YSB3YXJuaW5nIGFuZApicmVha3MgaW50byB0aGUgY29tcGxldGlvbiBjaGVja3M6CgoJaWYgKCFj b250cm9sbGVyX2lzX2RvbmUoaTJjKSkgewoJCWdvdG8gaXJxX3RyYW5zX291dDsKCX0KCklmIGEg dGhyZXNob2xkIGludGVycnVwdCBmaXJlcyB3aGlsZSBpbiBBOV9TVEFURV9JRExFIGFuZCBjb250 cm9sbGVyX2lzX2RvbmUoKQppcyBmYWxzZSwgYW1sX2kyY19pcnEoKSBqdW1wcyB0byBpcnFfdHJh bnNfb3V0IGFuZCByZXR1cm5zIElSUV9IQU5ETEVEIHdpdGhvdXQKY2xlYXJpbmcgUkVHX0NGR19J UlFfU1RBVEUgb3IgbWFza2luZyB0aGUgdGhyZXNob2xkIGludGVycnVwdCBpbgpSRUdfQ0ZHX0lS UV9FTkFCTEUsIGxlYXZpbmcgdGhlIGludGVycnVwdCBhc3NlcnRlZC4gQ29udmVyc2VseSwgaWYK Y29udHJvbGxlcl9pc19kb25lKCkgaXMgdHJ1ZSAoc3VjaCBhcyBhIGxhdGUgQTlfUEhZX0RPTkUp LCBleGVjdXRpb24gZmFsbHMKdGhyb3VnaCB0byBjb21wbGV0ZV9pcnFfb3V0IGFuZCBzcHVyaW91 c2x5IHNpZ25hbHMgaTJjLT5kb25lIHdoaWxlIGlkbGUuCgpTaG91bGQgYW1sX2kyY19pcnEoKSBj aGVjayBmb3IgQTlfU1RBVEVfSURMRSB1cCBmcm9udCwgZGlzYWJsZSB0aHJlc2hvbGQKaW50ZXJy dXB0cywgY2xlYXIgUkVHX0NGR19JUlFfU1RBVEUsIGFuZCByZXR1cm4gd2l0aG91dCBjYWxsaW5n CmNvbXBsZXRlKCZpMmMtPmRvbmUpPwoKPiArCj4gK3N0YXRpYyB2b2lkIGFtbF9pMmNfZG9fc3Rh cnQoc3RydWN0IGFtbF9pMmMgKmkyYywgc3RydWN0IGkyY19tc2cgKm1zZykKPiArewo+ICsJdW5z aWduZWQgaW50IHJlZ192YWw7Cj4gKwl1bnNpZ25lZCBpbnQgdHJhbnNfbGVuOwo+ICsKPiArCXRy YW5zX2xlbiA9IG1zZy0+bGVuOwo+ICsJcmVnX3ZhbCA9ICh1bnNpZ25lZCBpbnQpKChtc2ctPmFk ZHIgPDwgU1RBUlRfU0FERFJfU0hJRlQpIHwKPiArCQkJCSgobXNnLT5mbGFncyAmIEkyQ19NX1JE KSA/IFNUQVJUX1JFQUQgOiAwKSB8Cj4gKwkJCQkoKHRyYW5zX2xlbiAmIDB4ZmZmKSA8PCBTVEFS VF9MRU5fU0hJRlQpIHwgU1RBUlRfU1RBUlQpOwo+ICsJYW1sX2kyY19zZXRfbWFzayhpMmMsIFJF R19DRkdfU1RBUlQsCj4gKwkJCSBTVEFSVF9TVEFSVCB8IFNUQVJUX1NMQVZFX0FERFIgfCBTVEFS VF9SRUFEIHwgU1RBUlRfTEVOLCByZWdfdmFsKTsKCltTZXZlcml0eTogTWVkaXVtXQpJbiBkcml2 ZXJzL2kyYy9idXNzZXMvaTJjLWFtbG9naWMtYTkuYzphbWxfaTJjX2RvX3N0YXJ0KCksIGNvdWxk IHVwcGVyIGJpdHMgaW4KbXNnLT5hZGRyIGNvcnJ1cHQgdGhlIFNUQVJUX0xFTiBmaWVsZCBvZiBS RUdfQ0ZHX1NUQVJUPwoKV2hlbiB1c2Vyc3BhY2Ugc3VibWl0cyBhbiBJMkNfUkRXUiBpb2N0bCBv biAvZGV2L2kyYy0qLCBtc2ctPmFkZHIgaXMgYSB1MTYKcGFzc2VkIHRocm91Z2ggaTJjZGV2X2lv Y3RsX3Jkd3IoKSAtPiBpMmNfdHJhbnNmZXIoKSAtPiBhbWxfaTJjX3hmZXIoKSAtPgphbWxfaTJj X3hmZXJfbXNnKCkgLT4gYW1sX2kyY19kb19zdGFydCgpIHdpdGhvdXQgbWFza2luZy4gQmVjYXVz ZQptc2ctPmFkZHIgPDwgU1RBUlRfU0FERFJfU0hJRlQgaXMgbm90IG1hc2tlZCB0byA3IGJpdHMg KG9yIFNUQVJUX1NMQVZFX0FERFIpCmJlZm9yZSBiZWluZyBPUmVkIHdpdGggKHRyYW5zX2xlbiAm IDB4ZmZmKSA8PCBTVEFSVF9MRU5fU0hJRlQgYW5kIHdyaXR0ZW4gdmlhCmFtbF9pMmNfc2V0X21h c2soKSB1bmRlciB0aGUgY29tYmluZWQgbWFzayBTVEFSVF9TVEFSVCB8IFNUQVJUX1NMQVZFX0FE RFIgfApTVEFSVF9SRUFEIHwgU1RBUlRfTEVOLCBhbnkgYml0cyBzZXQgaW4gbXNnLT5hZGRyWzE1 OjExXSBzaGlmdCBpbnRvClNUQVJUX0xFTiAoR0VOTUFTSygyMywgMTIpKSBhbmQgYWx0ZXIgdGhl IGhhcmR3YXJlIHRyYW5zZmVyIGxlbmd0aC4KClNob3VsZCBtc2ctPmFkZHIgYmUgbWFza2VkIChm b3IgZXhhbXBsZSB3aXRoIDB4N2YsIHNpbmNlIDEwLWJpdCBhZGRyZXNzaW5nIGlzCm5vdCBhZHZl cnRpc2VkIGluIGFtbF9pMmNfZnVuYygpKSBiZWZvcmUgc2hpZnRpbmcgYnkgU1RBUlRfU0FERFJf U0hJRlQ/Cgo+ICsJY2xlYXJfaXJxX3N0YXR1cyhpMmMsIElSUV9BTExfTUFTSyk7Cj4gKwkvKiBl bmFibGUgdGhyZXNoIG1vZGUgKi8KPiArCWlmICh0cmFuc19sZW4gPiBBOV9JMkNfRklGT19ERVBU SCkgewo+ICsJCXJlZ192YWwgPSAobXNnLT5mbGFncyAmIEkyQ19NX1JEKSA/IEE5X1JYX1RIUkVT SF9SRUFEIDogQTlfVFhfVEhSRVNIX1dSSVRFOwo+ICsJCWFtbF9pMmNfc2V0X21hc2soaTJjLCBS RUdfQ0ZHX0lSUV9FTkFCTEUsCj4gKwkJCQkgQTlfUlhfVEhSRVNIX1JFQUQgfCBBOV9UWF9USFJF U0hfV1JJVEUsIHJlZ192YWwpOwo+ICsJfQo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGFtbF9pMmNf eGZlcl9tc2coc3RydWN0IGFtbF9pMmMgKmkyYywgc3RydWN0IGkyY19tc2cgKm1zZywgYm9vbCBs YXN0KQo+ICt7Cj4gKwl1bnNpZ25lZCBsb25nIHRpbWVfbGVmdCwgZmxhZ3M7Cj4gKwlpbnQgcmV0 ID0gMDsKPiArCj4gKwlpMmMtPm1zZyA9IG1zZzsKPiArCWkyYy0+cG9zID0gMDsKPiArCWkyYy0+ Y291bnQgPSAwOwo+ICsJaTJjLT5lcnJvciA9IDA7Cj4gKwo+ICsJaTJjLT5zdGF0ZSA9IChtc2ct PmZsYWdzICYgSTJDX01fUkQpID8gQTlfU1RBVEVfUkVBRCA6IEE5X1NUQVRFX1dSSVRFOwo+ICsJ c3Bpbl9sb2NrX2lycXNhdmUoJmkyYy0+bG9jaywgZmxhZ3MpOwo+ICsJYW1sX2kyY19wcmVwYXJl X3hmZXIoaTJjLCBBOV9GSUZPX0ZJTExfRlVMTCk7Cj4gKwlpMmMtPnBvcyArPSBpMmMtPmNvdW50 Owo+ICsJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmaTJjLT5sb2NrLCBmbGFncyk7Cj4gKwlyZWlu aXRfY29tcGxldGlvbigmaTJjLT5kb25lKTsKPiArCj4gKwlpZiAobGFzdCkKPiArCQlhbWxfaTJj X3NldF9tYXNrKGkyYywgUkVHX0NGR19CVVMsIEJVU19OT19TVE9QLCAwKTsKPiArCWVsc2UKPiAr CQlhbWxfaTJjX3NldF9tYXNrKGkyYywgUkVHX0NGR19CVVMsIEJVU19OT19TVE9QLCBCVVNfTk9f U1RPUCk7Cj4gKwkvKiBTdGFydCB0aGUgdHJhbnNmZXIgKi8KPiArCWFtbF9pMmNfZG9fc3RhcnQo aTJjLCBtc2cpOwoKW1NldmVyaXR5OiBIaWdoXQpDYW4gc3RhcnRpbmcgdGhlIGhhcmR3YXJlIHRy YW5zZmVyIGJlZm9yZSBjbGVhcmluZyBJUlEgc3RhdHVzIGFuZCBlbmFibGluZwp0aHJlc2hvbGQg aW50ZXJydXB0cyBpbiBkcml2ZXJzL2kyYy9idXNzZXMvaTJjLWFtbG9naWMtYTkuYzphbWxfaTJj X2RvX3N0YXJ0KCksCndpdGhvdXQgaG9sZGluZyBpMmMtPmxvY2sgYWNyb3NzIHRyYW5zZmVyIHNl dHVwIGluIGFtbF9pMmNfeGZlcl9tc2coKSwgcmFjZQp3aXRoIGFtbF9pMmNfaXJxKCk/CgpJbiBh bWxfaTJjX2RvX3N0YXJ0KCksIHNldHRpbmcgU1RBUlRfU1RBUlQgaW4gUkVHX0NGR19TVEFSVCBr aWNrcyBvZmYgdGhlCmhhcmR3YXJlIHRyYW5zYWN0aW9uIGJlZm9yZSBjbGVhcl9pcnFfc3RhdHVz KGkyYywgSVJRX0FMTF9NQVNLKSBhbmQgYmVmb3JlCmVuYWJsaW5nIEE5X1JYX1RIUkVTSF9SRUFE IG9yIEE5X1RYX1RIUkVTSF9XUklURSBpbiBSRUdfQ0ZHX0lSUV9FTkFCTEU6CgoJYW1sX2kyY19z ZXRfbWFzayhpMmMsIFJFR19DRkdfU1RBUlQsCgkJCSBTVEFSVF9TVEFSVCB8IFNUQVJUX1NMQVZF X0FERFIgfCBTVEFSVF9SRUFEIHwgU1RBUlRfTEVOLCByZWdfdmFsKTsKCWNsZWFyX2lycV9zdGF0 dXMoaTJjLCBJUlFfQUxMX01BU0spOwoJLyogZW5hYmxlIHRocmVzaCBtb2RlICovCglpZiAodHJh bnNfbGVuID4gQTlfSTJDX0ZJRk9fREVQVEgpIHsKCQlyZWdfdmFsID0gKG1zZy0+ZmxhZ3MgJiBJ MkNfTV9SRCkgPyBBOV9SWF9USFJFU0hfUkVBRCA6IEE5X1RYX1RIUkVTSF9XUklURTsKCQlhbWxf aTJjX3NldF9tYXNrKGkyYywgUkVHX0NGR19JUlFfRU5BQkxFLAoJCQkJIEE5X1JYX1RIUkVTSF9S RUFEIHwgQTlfVFhfVEhSRVNIX1dSSVRFLCByZWdfdmFsKTsKCX0KCklmIHRoZSB0YXNrIGlzIHBy ZWVtcHRlZCBvciBpbnRlcnJ1cHRlZCBhZnRlciB3cml0aW5nIFJFR19DRkdfU1RBUlQsIG9yIGlm IHRoZQpjb250cm9sbGVyIHF1aWNrbHkgYXNzZXJ0cyBBOV9OQ0tfRVJST1IgKHN1Y2ggYXMgb24g YW4gYWRkcmVzcyBOQUNLKSBvcgpBOV9QSFlfRE9ORSBiZWZvcmUgY2xlYXJfaXJxX3N0YXR1cygp IHJ1bnMsIGNsZWFyX2lycV9zdGF0dXMoaTJjLCBJUlFfQUxMX01BU0spCmNhbiB3aXBlIG91dCB0 aGUgbmV3bHkgYXNzZXJ0ZWQgSVJRIHN0YXR1cyBiaXRzIGFuZCBjYXVzZQp3YWl0X2Zvcl9jb21w bGV0aW9uX3RpbWVvdXQoKSB0byB0aW1lIG91dC4gU2ltaWxhcmx5LCBpZiBhbWxfaTJjX2lycSgp IHJ1bnMKYW5kIGNvbXBsZXRlcyBvbiBhbiBlYXJseSBOQUNLIGJlZm9yZSBhbWxfaTJjX2RvX3N0 YXJ0KCkgdXBkYXRlcwpSRUdfQ0ZHX0lSUV9FTkFCTEUsIHRoZSB1bmxvY2tlZCByZWFkLW1vZGlm eS13cml0ZSBpbiBhbWxfaTJjX2RvX3N0YXJ0KCkgY2FuCnJlLWVuYWJsZSBBOV9SWF9USFJFU0hf UkVBRCBvciBBOV9UWF9USFJFU0hfV1JJVEUgYWZ0ZXIgY29tcGxldGVfaXJxX291dAphbHJlYWR5 IGNsZWFyZWQgdGhlbS4KCkluIGFkZGl0aW9uLCBpbiBhbWxfaTJjX3hmZXJfbXNnKCksIGkyYy0+ bXNnLCBpMmMtPnBvcywgaTJjLT5jb3VudCwKaTJjLT5lcnJvciwgYW5kIGkyYy0+c3RhdGUgYXJl IGluaXRpYWxpemVkIG91dHNpZGUgaTJjLT5sb2NrLCBhbmQgaTJjLT5sb2NrIGlzCnJlbGVhc2Vk IGJlZm9yZSByZWluaXRfY29tcGxldGlvbigmaTJjLT5kb25lKSwgUkVHX0NGR19CVVMgY29uZmln dXJhdGlvbiwgYW5kCmFtbF9pMmNfZG9fc3RhcnQoKS4gSWYgYSBsYXRlIGludGVycnVwdCBmcm9t IGEgcHJldmlvdXMgdGltZWQtb3V0IHRyYW5zZmVyCmFycml2ZXMgd2hpbGUgaTJjLT5zdGF0ZSBp cyBhbHJlYWR5IHNldCB0byBBOV9TVEFURV9SRUFEIG9yIEE5X1NUQVRFX1dSSVRFLAphbWxfaTJj X2lycSgpIGNhbiBtb2RpZnkgaTJjLT5wb3MgYW5kIGFjY2VzcyB0aGUgbmV3IGkyYy0+bXNnLT5i dWYgYmVmb3JlIHRoZQpuZXcgdHJhbnNmZXIgYmVnaW5zIChhbmQgaWYgaTJjLT5wb3MgZXhjZWVk cyB0aGUgbmV3IG1zZy0+bGVuIGluCkE5X1NUQVRFX1JFQUQsIHRoZSBzaWduZWQgc3VidHJhY3Rp b24gaTJjLT5tc2ctPmxlbiAtIGkyYy0+cG9zIGluCm1pbihpMmMtPm1zZy0+bGVuIC0gaTJjLT5w b3MsIEE5X0kyQ19GSUZPX0RFUFRIKSB3aWxsIHdyYXAgdG8gYSBsYXJnZSB1MzIgaW4KcmRfbGVu IGFuZCBvdmVyZmxvdyBidWZbaTJjLT5wb3MrK10pLgoKQ291bGQgdGhlIHN0YXRlIGluaXRpYWxp emF0aW9uLCByZWluaXRfY29tcGxldGlvbigpLCBidXMgY29uZmlndXJhdGlvbiwgSVJRCnN0YXR1 cyBjbGVhcmluZywgdGhyZXNob2xkIElSUSBzZXR1cCwgYW5kIFNUQVJUX1NUQVJUIHRyaWdnZXIg YWxsIGJlIHBlcmZvcm1lZAp1bmRlciBhIHNpbmdsZSBzcGluX2xvY2tfaXJxc2F2ZSgmaTJjLT5s b2NrLCBmbGFncykgY3JpdGljYWwgc2VjdGlvbiwgd2l0aApjbGVhcl9pcnFfc3RhdHVzKCkgYW5k IFJFR19DRkdfSVJRX0VOQUJMRSBjb25maWd1cmVkIGJlZm9yZSBhc3NlcnRpbmcKU1RBUlRfU1RB UlQ/Cgo+ICsKPiArCXRpbWVfbGVmdCA9IG1zZWNzX3RvX2ppZmZpZXMoSTJDX1RJTUVPVVRfTVMp Owo+ICsJdGltZV9sZWZ0ID0gd2FpdF9mb3JfY29tcGxldGlvbl90aW1lb3V0KCZpMmMtPmRvbmUs IHRpbWVfbGVmdCk7Cj4gKwo+ICsJLyoKPiArCSAqIFByb3RlY3QgYWNjZXNzIHRvIGkyYyBzdHJ1 Y3QgYW5kIHJlZ2lzdGVycyBmcm9tIGludGVycnVwdAo+ICsJICogaGFuZGxlcnMgdHJpZ2dlcmVk IGJ5IGEgdHJhbnNmZXIgdGVybWluYXRlZCBhZnRlciB0aGUKPiArCSAqIHRpbWVvdXQgcGVyaW9k Cj4gKwkgKi8KPiArCj4gKwlzcGluX2xvY2tfaXJxc2F2ZSgmaTJjLT5sb2NrLCBmbGFncyk7Cj4g KwlpZiAoIXRpbWVfbGVmdCkgewo+ICsJCWkyYy0+c3RhdGUgPSBBOV9TVEFURV9JRExFOwo+ICsJ CWNsZWFyX2lycV9zdGF0dXMoaTJjLCBJUlFfQUxMX01BU0spOwo+ICsJCXJlc2V0X2ZpZm9fcG9z KGkyYyk7Cj4gKwkJcmV0ID0gLUVUSU1FRE9VVDsKPiArCX0KCltTZXZlcml0eTogSGlnaF0KV2hl biBhIHRyYW5zZmVyIHdpdGggbXNnLT5sZW4gPiBBOV9JMkNfRklGT19ERVBUSCB0aW1lcyBvdXQg aW4KZHJpdmVycy9pMmMvYnVzc2VzL2kyYy1hbWxvZ2ljLWE5LmM6YW1sX2kyY194ZmVyX21zZygp LCBhcmVuJ3QgdGhlIHRocmVzaG9sZAppbnRlcnJ1cHRzIGluIFJFR19DRkdfSVJRX0VOQUJMRSBh bmQgdGhlIGFjdGl2ZSB0cmFuc2ZlciBpbiBSRUdfQ0ZHX1NUQVJUIGxlZnQKZW5hYmxlZD8KCklu IGFtbF9pMmNfZG9fc3RhcnQoKSwgdHJhbnNmZXJzIHdpdGggdHJhbnNfbGVuID4gQTlfSTJDX0ZJ Rk9fREVQVEggZW5hYmxlCkE5X1JYX1RIUkVTSF9SRUFEIG9yIEE5X1RYX1RIUkVTSF9XUklURSBp biBSRUdfQ0ZHX0lSUV9FTkFCTEUsIGFuZCBvbmx5CnVwZGF0ZSBSRUdfQ0ZHX0lSUV9FTkFCTEUg d2hlbiB0cmFuc19sZW4gPiBBOV9JMkNfRklGT19ERVBUSC4gT24gbm9ybWFsCmNvbXBsZXRpb24g aW4gYW1sX2kyY19pcnEoKSwgY29tcGxldGVfaXJxX291dCBjbGVhcnMgQTlfUlhfVEhSRVNIX1JF QUQgfApBOV9UWF9USFJFU0hfV1JJVEUgaW4gUkVHX0NGR19JUlFfRU5BQkxFLCBidXQgdGhlICF0 aW1lX2xlZnQgdGltZW91dCBwYXRoIGluCmFtbF9pMmNfeGZlcl9tc2coKSBkb2VzIG5vdCBkaXNh YmxlIHRob3NlIHRocmVzaG9sZCBJUlEgYml0cyBvciBzdG9wIHRoZQp0cmFuc2ZlciBpbiBSRUdf Q0ZHX1NUQVJULgoKSWYgYSA+MzItYnl0ZSB3cml0ZSB0aW1lcyBvdXQgYW5kIHRoZSBuZXh0IHRy YW5zZmVyIGlzIGEgc2hvcnQgcmVhZCB3aXRoCm1zZy0+bGVuIDw9IDMyLCB3b3VsZG4ndCBBOV9U WF9USFJFU0hfV1JJVEUgcmVtYWluIGVuYWJsZWQgYW5kIGZpcmUgZHVyaW5nCkE5X1NUQVRFX1JF QUQsIGNhdXNpbmcgYW1sX2kyY19pcnEoKSB0byByZWFkIGZyb20gYW4gZW1wdHkgUkVHX0NGR19S WCBGSUZPCmludG8gbXNnLT5idWY/CgpbIC4uLiBdCgo+ICtNT0RVTEVfREVTQ1JJUFRJT04oIkFt bG9naWMgSTJDIEJ1cyBkcml2ZXIiKTsKPiArTU9EVUxFX0FVVEhPUigiSnVueWkgWmhhbyA8anVu eWkuemhhb0BhbWxvZ2ljLmNvbT4iKTsKPiArTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwoKLS0gClNh c2hpa28gQUkgcmV2aWV3IMK3IGh0dHBzOi8vc2FzaGlrby5kZXYvIy9wYXRjaHNldC8yMDI2MTAy Mi1hOS1pMmMtdjItMC00NWUzY2VmMTc1YmZAYW1sb2dpYy5jb20/cGFydD0yCgpfX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hbWxvZ2ljIG1haWxp bmcgbGlzdApsaW51eC1hbWxvZ2ljQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmlu ZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hbWxvZ2ljCg==