From: sashiko-bot@kernel.org
To: "Petar Stepanovic" <pstepanovic@axiado.com>
Cc: linux-usb@vger.kernel.org, devicetree@vger.kernel.org,
robh@kernel.org, conor+dt@kernel.org
Subject: Re: [PATCH v5 6/6] usb: gadget: udc: crg: Add core driver and build integration
Date: Mon, 16 Nov 2026 21:15:04 +0000 [thread overview]
Message-ID: <sashiko-outbox-217695@kernel.org> (raw)
In-Reply-To: <20261116-axiado-ax3000-usb-device-controller-v5-6-49271ed5c793@axiado.com>
Thank you for your contribution! Sashiko AI review found 10 potential
issues to consider:
- [High] usb: gadget: crg: unhandled level IRQ storm in
crg_udc_common_irq()
- [High] usb: gadget: crg: broken endpoint teardown and UAF in
crg_udc_suspend()
- [Medium] usb: gadget: crg: missing crg_udc_prepare_for_setup() in port
reset workers
- [Medium] usb: gadget: crg: unscheduled external reset on
crg_udc_recover() timeout
- [Medium] usb: gadget: crg: lost link restart in crg_udc_restart_link()
during reset
- [Medium] usb: gadget: crg: lost disconnect on SYS_ERR when
bus_reset_pending is set
- [Medium] usb: gadget: crg: uncancelled work items on probe error and
remove
- [Medium] usb: gadget: crg: uncleared connected flag before disconnect
on SYS_ERR
- [Medium] usb: gadget: crg: missing DMA quiescence wait in
crg_udc_shutdown()
- [Medium] usb: gadget: udc: crg: lost reset notification in
crg_udc_handle_port_status()
--
commit 808e1b308d74053a13eba452fa900f8bf2bf60a5
Author: Petar Stepanovic <pstepanovic@axiado.com>
usb: gadget: udc: crg: Add core driver and build integration
This patch adds the core platform driver, interrupt handling, reset and
recovery logic, and Kconfig/Makefile integration for the Corigine/Axiado
AX3000/AX3005 USB Device Controller.
> diff --git a/drivers/usb/gadget/udc/crg/crg-udc-core.c b/drivers/usb/gadget/udc/crg/crg-udc-core.c
> new file mode 100644
> index 0000000000000..e508dbd45339f
> --- /dev/null
> +++ b/drivers/usb/gadget/udc/crg/crg-udc-core.c
[ ... ]
> + crg_udc->resetting = false;
> +
> + ret = crg_gadget_irq_init(pdev, crg_udc);
> + if (ret)
> + goto err_free_resources;
> +
> + ret = usb_add_gadget(&crg_udc->gadget);
> + if (ret)
> + goto err_free_resources;
> +
> + return 0;
> +
> +err_free_resources:
> + crg_udc_free_resources(crg_udc);
> +err_put_gadget:
> + usb_put_gadget(&crg_udc->gadget);
> + return ret;
> +}
> +
> +static void crg_udc_remove(struct platform_device *pdev)
> +{
> + struct crg_gadget_dev *crg_udc = platform_get_drvdata(pdev);
> + unsigned long flags;
> + u32 tmp;
> +
> + spin_lock_irqsave(&crg_udc->udc_lock, flags);
> + crg_udc->shutting_down = true;
> + spin_unlock_irqrestore(&crg_udc->udc_lock, flags);
> +
> + /* The gadget core calls pullup(0) before the disconnect callback. */
> + usb_del_gadget(&crg_udc->gadget);
> + cancel_delayed_work_sync(&crg_udc->port_retry_work);
> + cancel_work_sync(&crg_udc->recovery_work);
> + cancel_work_sync(&crg_udc->udc_reset_work);
> + crg_udc_free_resources(crg_udc);
[Severity: Medium]
Can an interrupt scheduled between crg_gadget_irq_init() and a failing
usb_add_gadget() leave port_retry_work, recovery_work, or udc_reset_work
queued after crg_udc is freed?
crg_udc_free_resources() synchronizes and frees the IRQ, then frees the DMA
rings, without cancelling those three work items before usb_put_gadget()
frees crg_udc. In crg_udc_remove(), the work items are also cancelled
before crg_udc_free_resources() synchronizes and frees the IRQ rather than
after.
> +
> + /* Do not access registers while the external reset is asserted. */
> + if (!crg_udc->hw_reset_asserted && !crg_udc->dma_quiesce_failed) {
> + tmp = readl(crg_udc->mmio_virt_base + CRG_UDC_MODE_REG) & ~0x1;
> + writel(tmp, crg_udc->mmio_virt_base + CRG_UDC_MODE_REG);
> + }
> +
> + platform_set_drvdata(pdev, NULL);
> + usb_put_gadget(&crg_udc->gadget);
> +}
> +
> +static void crg_udc_shutdown(struct platform_device *pdev)
> +{
> + struct crg_gadget_dev *crg_udc = platform_get_drvdata(pdev);
> + unsigned long flags;
> +
> + spin_lock_irqsave(&crg_udc->udc_lock, flags);
> + crg_udc->pullup_on = false;
> + crg_udc->shutting_down = true;
> + crg_udc->resetting = true;
> + crg_udc->device_state = USB_STATE_ATTACHED;
> + spin_unlock_irqrestore(&crg_udc->udc_lock, flags);
> + if (crg_udc->irq >= 0)
> + synchronize_irq(crg_udc->irq);
> + cancel_delayed_work_sync(&crg_udc->port_retry_work);
> + cancel_work_sync(&crg_udc->recovery_work);
> + cancel_work_sync(&crg_udc->udc_reset_work);
> +
> + /* Reset and gadget stop may own the registers across a lock drop. */
> + spin_lock_irq(&crg_udc->udc_lock);
> + wait_event_lock_irq(crg_udc->teardown_wait,
> + !crg_udc->controller_recovering, crg_udc->udc_lock);
> + if (crg_udc->uccr && !crg_udc->hw_reset_asserted) {
> + u32 val = readl(&crg_udc->uccr->control);
> +
> + crg_udc_set_vbus_detect(crg_udc, false);
> + val &= ~(CRG_U3DC_CTRL_INT_EN | CRG_U3DC_CTRL_RUN |
> + CRG_U3DC_CTRL_SYSERR_EN);
> + writel(val, &crg_udc->uccr->control);
> + }
> + spin_unlock_irq(&crg_udc->udc_lock);
> +}
[Severity: Medium]
Does crg_udc_shutdown() return before bus-master DMA has actually stopped?
As noted in crg_udc_soft_reset(), clearing CRG_U3DC_CTRL_RUN does not halt
DMA or pending event-ring writes until CRG_U3DC_STATUS_DEV_CTRL_HALT
asserts. Returning without waiting for halt or calling crg_udc_quiesce_hw()
leaves DMA active across shutdown or kexec.
> +
> +static int crg_udc_suspend(struct device *dev)
> +{
> + struct crg_gadget_dev *crg_udc = dev_get_drvdata(dev);
> + unsigned long flags;
> + u32 val;
> + int ret;
> +
> + spin_lock_irqsave(&crg_udc->udc_lock, flags);
> + if (crg_udc->controller_recovering || crg_udc->shutting_down ||
> + crg_udc->external_reset_pending ||
> + crg_udc->endpoint_recovery_pending ||
> + (crg_udc->hw_reset_asserted && !crg_udc->gadget_stopping)) {
> + spin_unlock_irqrestore(&crg_udc->udc_lock, flags);
> + return -EBUSY;
> + }
> + crg_udc->suspended = true;
> + if (crg_udc->gadget_stopping) {
> + if (crg_udc->hw_dma_armed) {
> + crg_udc->suspended = false;
> + ret = -EBUSY;
> + } else {
> + ret = 0;
> + }
> + spin_unlock_irqrestore(&crg_udc->udc_lock, flags);
> + return ret;
> + }
> + crg_udc_set_pullup(crg_udc, false);
> + val = readl(&crg_udc->uccr->control);
> + val &= ~CRG_U3DC_CTRL_INT_EN;
> + writel(val, &crg_udc->uccr->control);
> + spin_unlock_irqrestore(&crg_udc->udc_lock, flags);
> +
> + if (crg_udc->irq >= 0)
> + synchronize_irq(crg_udc->irq);
> + cancel_delayed_work_sync(&crg_udc->port_retry_work);
> + cancel_work_sync(&crg_udc->recovery_work);
> + cancel_work_sync(&crg_udc->udc_reset_work);
> +
> + spin_lock_irqsave(&crg_udc->udc_lock, flags);
> + if (crg_udc->gadget_stopping || crg_udc->shutting_down ||
> + crg_udc->controller_recovering || crg_udc->external_reset_pending ||
> + crg_udc->endpoint_recovery_pending) {
> + ret = -EBUSY;
> + goto out;
> + }
> + /*
> + * A reset may already have marked the link disconnected while its
> + * gadget notification was still pending. Deliver disconnect before
> + * resetting the software state, including that cancelled work.
> + */
> + if (crg_udc->connected || crg_udc->bus_reset_pending)
> + crg_udc_notify_disconnect(crg_udc, &flags);
> + crg_udc->connected = false;
> + crg_udc->gadget.speed = USB_SPEED_UNKNOWN;
> + if (crg_udc->external_reset_pending || crg_udc->endpoint_recovery_pending) {
> + ret = -EBUSY;
> + goto out;
> + }
> + ret = crg_udc_recover(crg_udc, &flags);
> + if (ret)
> + dev_err(crg_udc->dev, "suspend controller reset failed: %d\n", ret);
> +out:
> + if (ret) {
> + crg_udc->suspended = false;
> + crg_udc_kick_reset_work(crg_udc);
> + }
> + spin_unlock_irqrestore(&crg_udc->udc_lock, flags);
> + return ret;
> +}
[Severity: High]
Can crg_udc_suspend() cause a use-after-free on queued usb_requests when
crg_udc_notify_disconnect() disables endpoints?
crg_udc_suspend() sets crg_udc->suspended = true and clears CRG_U3DC_CTRL_RUN
via crg_udc_set_pullup(crg_udc, false) before calling
crg_udc_notify_disconnect() and crg_udc_recover(). When the gadget driver's
->disconnect() callback invokes usb_ep_disable() -> crg_udc_ep_disable() on
an active endpoint, polling uccr->ep_enable or uccr->ep_running can time out
with RUN cleared and call crg_udc_recover_endpoints() ->
crg_udc_recover_link(). Because crg_udc_recover_link() rejects
crg_udc->suspended with -EBUSY, usb_ep_disable() returns without stopping DMA
or draining udc_ep->queue, and the function driver frees its usb_requests
before crg_udc_recover() -> crg_udc_reset_queues() -> crg_udc_ep_nuke() gives
them back.
In addition, if usb_ep_dequeue() runs during that window,
crg_udc_abort_ep0_for_setup() or CRG_CMD_STOP_EP fails because suspended is
set and RUN is clear, setting endpoint_recovery_pending = true and causing
crg_udc_suspend() to abort with -EBUSY instead of running crg_udc_recover().
And if crg_udc_suspend() takes the early goto out before crg_udc_recover(),
CRG_U3DC_CTRL_RUN and CRG_U3DC_CTRL_INT_EN remain cleared while
crg_udc->suspended is reset to false.
[ ... ]
> + if (tmp_status & CRG_U3DC_STATUS_SYS_ERR) {
> + bool was_connected = crg_udc->connected;
> + u32 generation = crg_udc->udc_event[0].generation;
> +
> + /* A controller reset must not overlap composite's ->reset(). */
> + if (crg_udc->reset_callback_active) {
> + writel(CRG_U3DC_STATUS_SYS_ERR, &uccr->status);
> + crg_udc->deferred_system_error = true;
> + spin_unlock_irqrestore(&crg_udc->udc_lock, flags);
> + return;
> + }
> +
> + dev_err(crg_udc->dev, "controller system error\n");
> + writel(CRG_U3DC_STATUS_SYS_ERR, &uccr->status);
> + /* Function drivers must see enabled endpoints on disconnect. */
> + if (was_connected)
> + crg_udc_notify_disconnect(crg_udc, &flags);
[Severity: Medium]
If CRG_U3DC_STATUS_SYS_ERR fires after a bus reset has already cleared
crg_udc->connected while crg_udc->bus_reset_pending is still true, does this
drop the gadget reset/disconnect notification?
Unlike crg_udc_suspend(), which checks crg_udc->connected ||
crg_udc->bus_reset_pending, this path only checks crg_udc->connected and
then calls crg_udc_recover_link(crg_udc, &flags, false), which clears
bus_reset_pending and marks all endpoints disabled without notifying the
gadget driver.
> + /*
> + * The disconnect callback drops udc_lock: another CPU may be
> + * resetting now, or may have reset and rebuilt the rings
> + * already, in which case this error has been recovered.
> + */
> + if (crg_udc->resetting || crg_udc->suspended ||
> + crg_udc->shutting_down ||
> + generation != crg_udc->udc_event[0].generation) {
> + spin_unlock_irqrestore(&crg_udc->udc_lock, flags);
> + return;
> + }
> + crg_udc_recover_link(crg_udc, &flags, false);
[Severity: Medium]
Should crg_udc->connected (and device_state) be cleared before calling
crg_udc_notify_disconnect() here?
Because crg_udc_notify_disconnect() drops udc_lock while crg_udc->connected
is still true and crg_udc->device_state is still USB_STATE_CONFIGURED, a
concurrent crg_udc_suspend() or port status handler can deliver a second
disconnect notification. Also, if usb_ep_disable() inside ->disconnect()
times out on the faulted controller and calls crg_udc_recover_endpoints(),
notify_reset evaluates to true (via device_state == USB_STATE_CONFIGURED and
gadget_callbacks_active) and queues a bus reset on top of the disconnect.
[ ... ]
> + if (crg_udc->device_state == USB_STATE_RECONNECTING &&
> + crg_udc->portsc_on_reconnecting == 1 &&
> + crg_udc_is_event_rings_empty(crg_udc)) {
> + crg_udc->portsc_on_reconnecting = 0;
> + crg_udc_handle_port_status(crg_udc, &flags);
> + /* The port handler drops udc_lock. */
> + if (crg_udc->resetting) {
> + spin_unlock_irqrestore(&crg_udc->udc_lock, flags);
> + return;
> + }
> + }
[Severity: Medium]
Can a second port event while crg_udc->bus_reset_pending is true clear
bus_reset_pending without notifying the gadget driver?
When an initial bus reset on a configured gadget runs crg_udc_reinit(crg_udc,
true), crg_udc->device_state becomes USB_STATE_RECONNECTING and
crg_udc->bus_reset_pending is set to true until udc_reset_work runs. If a
second port reset, a port-reset timeout in crg_udc_port_retry_work(), or a
CCS drop with VBUS present arrives before udc_reset_work runs, those paths
only check crg_udc->device_state == USB_STATE_CONFIGURED (or pass false to
crg_udc_reinit()):
drivers/usb/gadget/udc/crg/crg-udc-gadget.c:crg_udc_handle_port_status() {
...
bool was_configured = crg_udc->device_state ==
USB_STATE_CONFIGURED;
bool notify_reset = was_configured &&
crg_udc->async_callbacks &&
crg_udc->gadget_driver;
int reinit_ret;
reinit_ret = crg_udc_reinit(crg_udc, notify_reset);
...
}
crg_udc_reinit(crg_udc, false) then overwrites crg_udc->bus_reset_pending
with false and clears usb_ep.enabled on all endpoints without running
usb_gadget_udc_reset().
> +
> + if (crg_udc->device_state == USB_STATE_RECONNECTING &&
> + crg_udc->connected == 1) {
> + ret = crg_udc_prepare_for_setup(crg_udc);
> + if (!ret && crg_udc->pending_setup_valid &&
> + !crg_udc->resetting && crg_udc->connected &&
> + crg_udc->device_state == USB_STATE_DEFAULT) {
> + struct usb_ctrlrequest setup = crg_udc->pending_setup;
> + u8 tag = crg_udc->pending_setup_tag;
> +
> + crg_udc->pending_setup_valid = false;
> + crg_udc_dispatch_setup(crg_udc, &setup, tag, &flags);
> + } else if (ret && ret != -EBUSY) {
> + dev_err(crg_udc->dev,
> + "failed to prepare EP0 after reset: %d\n", ret);
> + }
> + }
[Severity: Medium]
What prepares EP0 and transitions device_state out of USB_STATE_RECONNECTING
when crg_udc_handle_port_status() is called from crg_udc_port_retry_work() or
crg_udc_reset_work()?
When a port reset on a session with device_state >= USB_STATE_DEFAULT
completes inside crg_udc_handle_port_status(), crg_udc_reinit() sets
device_state = USB_STATE_RECONNECTING and crg_udc_handle_port_status() sets
connected = 1 without calling crg_udc_enable_setup(). Only
crg_gadget_handle_interrupt() runs the USB_STATE_RECONNECTING block above to
call crg_udc_prepare_for_setup() and dispatch pending_setup; the two worker
callers of crg_udc_handle_port_status() return with the controller stuck in
USB_STATE_RECONNECTING.
> +
> + spin_unlock_irqrestore(&crg_udc->udc_lock, flags);
> +}
> +
> +/*
> + * Primary handler only checks whether the shared interrupt belongs to the
> + * controller. All controller work, including reset polling, runs in the
> + * threaded handler and therefore never busy-waits in hard IRQ context.
> + */
> +static irqreturn_t crg_udc_common_irq(int irq, void *dev)
> +{
> + struct crg_gadget_dev *crg_udc = dev;
> + struct crg_uccr __iomem *uccr = crg_udc->uccr;
> + u32 status;
> +
> + if (READ_ONCE(crg_udc->gadget_stopping) ||
> + READ_ONCE(crg_udc->shutting_down) ||
> + READ_ONCE(crg_udc->resetting))
> + return IRQ_NONE;
> +
> + status = readl(&uccr->status);
> + if (!(status & (CRG_U3DC_STATUS_EINT | CRG_U3DC_STATUS_SYS_ERR)))
> + return IRQ_NONE;
> +
> + return IRQ_WAKE_THREAD;
> +}
[Severity: High]
Can returning IRQ_NONE here while the level-triggered interrupt is still
asserted cause a hard-IRQ storm that disables the shared IRQ line?
The IRQ is registered with IRQF_SHARED | IRQF_ONESHOT, so the line is only
masked when crg_udc_common_irq() returns IRQ_WAKE_THREAD. Several paths set
resetting, shutting_down, or gadget_stopping and re-enable local interrupts
before CRG_U3DC_CTRL_INT_EN and CRG_U3DC_CTRL_SYSERR_EN are cleared in
uccr->control:
crg_udc_reset()
crg_udc_reset_session()
crg_udc->resetting = true;
spin_unlock_irqrestore(&crg_udc->udc_lock, *flags)
<hardirq>
crg_udc_common_irq()
if (READ_ONCE(crg_udc->resetting))
return IRQ_NONE; <-- level IRQ still asserted; storms
The same window exists in crg_udc_remove() during usb_del_gadget(), in
crg_udc_shutdown() before synchronize_irq(), and in crg_udc_stop_gadget()
when controller_recovering is true. Similarly, when suspended or
controller_recovering is true while resetting is false (such as during
crg_udc_reinit()), crg_udc_common_irq() wakes crg_udc_irq_thread(), which
returns early in crg_gadget_handle_interrupt() without clearing
uccr->status and unmasks the still-asserted level interrupt in a tight loop.
[ ... ]
> +static void crg_udc_restart_link(struct crg_gadget_dev *crg_udc,
> + bool notify_reset)
> +{
> + if (!crg_udc->async_callbacks || !crg_udc->gadget_driver ||
> + crg_udc->reset_callback_active)
> + return;
> +
> + if (notify_reset) {
> + crg_udc->bus_reset_pending = true;
> + crg_udc->restart_after_reset = true;
> + crg_udc_kick_reset_work(crg_udc);
> + } else if (!crg_udc->suspended && crg_udc->pullup_on) {
> + crg_udc_set_pullup(crg_udc, true);
> + }
> +}
[Severity: Medium]
If crg_udc_recover_endpoints() runs while crg_udc->reset_callback_active is
true, does this lose the post-reset pullup restart?
When usb_ep_disable() times out inside usb_gadget_udc_reset() and calls
crg_udc_recover_endpoints() -> crg_udc_recover_link(), crg_udc_reset() clears
crg_udc->restart_after_reset = false and resets the controller (clearing
CRG_U3DC_CTRL_RUN). crg_udc_restart_link() then returns early because
reset_callback_active is true, leaving restart_after_reset false when
crg_udc_reset_work() finishes.
[ ... ]
> +int crg_udc_recover(struct crg_gadget_dev *crg_udc, unsigned long *flags)
> +{
> + int ret;
> +
> + if (crg_udc->controller_recovering || crg_udc->shutting_down ||
> + crg_udc->gadget_stopping || crg_udc->hw_reset_asserted)
> + return -EBUSY;
> +
> + crg_udc_recovery_begin(crg_udc);
> + ret = crg_udc_reset(crg_udc, flags);
> + if (ret) {
> + crg_udc->controller_faulted = true;
> + crg_udc->dma_quiesce_failed = crg_udc->hw_dma_armed;
> + crg_udc_reset_queues(crg_udc, crg_udc->preserve_ep_enabled_on_reset);
> + }
> + if (!ret && !crg_udc->shutting_down && !crg_udc->gadget_stopping)
> + ret = crg_udc_reset_data_struct(crg_udc);
> + if (!ret && !crg_udc->shutting_down && !crg_udc->gadget_stopping)
> + ret = crg_udc_init_ep0(crg_udc);
> + if (!ret && (crg_udc->shutting_down || crg_udc->gadget_stopping))
> + ret = -ESHUTDOWN;
> +
> + crg_udc->controller_faulted = !!ret;
> + crg_udc->resetting = !!ret;
> + if (!ret)
> + crg_udc->stopped_needs_reset = false;
> + crg_udc_recovery_end(crg_udc);
> + return ret;
> +}
[Severity: Medium]
When crg_udc_reset() times out in crg_udc_recover(), should this set
crg_udc->external_reset_pending when crg_udc->dma_quiesce_failed &&
crg_udc->rst, like crg_udc_recover_link() does?
crg_udc_reset_session() clears external_reset_pending, and on timeout
crg_udc_reset_queues() quarantines any active DMA bounce buffers into
crg_udc->dma_quarantine. When crg_udc_recover() is called directly from
crg_udc_suspend() or crg_gadget_pullup(), external_reset_pending is never
set, so crg_udc_kick_reset_work() does not schedule recovery_work to assert
the external reset and release the quarantined buffers.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261116-axiado-ax3000-usb-device-controller-v5-0-49271ed5c793@axiado.com?part=6
prev parent reply other threads:[~2026-11-16 21:15 UTC|newest]
Thread overview: 13+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-16 19:06 [PATCH v5 0/6] Axiado AX3000 and AX3005 USB Device Controller (UDC) Petar Stepanovic
2026-11-16 19:06 ` [PATCH v5 1/6] dt-bindings: usb: gadget: udc: add Axiado AX3000 and AX3005 UDC Petar Stepanovic
2026-11-16 19:12 ` sashiko-bot
2026-11-16 19:06 ` [PATCH v5 2/6] usb: gadget: udc: crg: Add hardware definitions and structs Petar Stepanovic
2026-11-16 19:24 ` sashiko-bot
2026-11-16 19:06 ` [PATCH v5 3/6] usb: gadget: udc: crg: Add ring and transfer management Petar Stepanovic
2026-11-16 19:46 ` sashiko-bot
2026-11-16 19:06 ` [PATCH v5 4/6] usb: gadget: udc: crg: Add endpoint 0 handling Petar Stepanovic
2026-11-16 20:16 ` sashiko-bot
2026-11-16 19:06 ` [PATCH v5 5/6] usb: gadget: udc: crg: Add gadget and endpoint operations Petar Stepanovic
2026-11-16 20:47 ` sashiko-bot
2026-11-16 19:06 ` [PATCH v5 6/6] usb: gadget: udc: crg: Add core driver and build integration Petar Stepanovic
2026-11-16 21:15 ` sashiko-bot [this message]
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=sashiko-outbox-217695@kernel.org \
--to=sashiko-bot@kernel.org \
--cc=conor+dt@kernel.org \
--cc=devicetree@vger.kernel.org \
--cc=linux-usb@vger.kernel.org \
--cc=pstepanovic@axiado.com \
--cc=robh@kernel.org \
--cc=sashiko-reviews@lists.linux.dev \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.