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 5/6] usb: gadget: udc: crg: Add gadget and endpoint operations
Date: Mon, 16 Nov 2026 20:47:48 +0000 [thread overview]
Message-ID: <sashiko-outbox-217676@kernel.org> (raw)
In-Reply-To: <20261116-axiado-ax3000-usb-device-controller-v5-5-49271ed5c793@axiado.com>
Thank you for your contribution! Sashiko AI review found 10 potential
issues to consider:
- [High] usb: gadget: crg: stale deq_pt in crg_udc_ep_dequeue() when
pause_pt passed TD
- [High] usb: gadget: crg: stuck USB_STATE_RECONNECTING in worker
port-status paths
- [High] usb: gadget: crg: isoc endpoints wedged in EP_STATE_STOPPED on
xfer error
- [Medium] usb: gadget: crg: broken EP0 USB_ENDPOINT_HALT handling in
crg_udc_ep_halt()
- [Medium] usb: gadget: crg: request rejected on ring-full in
crg_udc_ep_queue()
- [Medium] usb: gadget: crg: premature USB_STATE_ADDRESS in
crg_udc_ep_disable()
- [Medium] usb: gadget: udc: crg: lost port reset poll in
crg_udc_port_retry_work()
- [Medium] usb: gadget: udc: crg: controller reset on nested
crg_udc_ep_dequeue()
- [Medium] usb: gadget: udc: crg: dequeue pointer rewind in
crg_udc_ep_halt()
- [Low] usb: gadget: crg: incomplete cleanup in crg_udc_ep_disable()
when disabled
--
commit 4ce545406bad41a031bcbc10a89cb66370b3d324
Author: Petar Stepanovic <pstepanovic@axiado.com>
usb: gadget: udc: crg: Add gadget and endpoint operations
This commit adds the USB gadget and endpoint operations, transfer ring
management, port status handling, and error recovery for the Axiado
AX3000/AX3005 UDC driver.
> diff --git a/drivers/usb/gadget/udc/crg/crg-udc-gadget.c b/drivers/usb/gadget/udc/crg-udc-gadget.c
> new file mode 100644
> index 0000000000000..dddfc5cf3d3ec
> --- /dev/null
> +++ b/drivers/usb/gadget/udc/crg/crg-udc-gadget.c
[ ... ]
> +static int crg_udc_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
> +{
[ ... ]
> + /* A stopped ring may still contain published requests. */
> + if (old_ep_state == EP_STATE_STOPPED) {
> + ret = -EBUSY;
> + goto recover;
> + }
> +
> + if (old_ep_state == EP_STATE_RUNNING) {
> + ret = crg_udc_issue_command(crg_udc, CRG_CMD_STOP_EP,
> + BIT(dci), 0);
> +
> + if (ret)
> + goto recover;
> + ret = readl_poll_timeout_atomic(&uccr->ep_running, tmp,
> + !(tmp & BIT(dci)), 10, 10000);
> + if (ret)
> + goto recover;
> + udc_ep_ptr->ep_state = EP_STATE_STOPPED;
> + udc_ep_ptr->dequeue_paused = true;
> + }
[Severity: Medium]
Does a nested or concurrent crg_udc_ep_dequeue() trigger a full controller
recovery reset when a second request with live TRBs is dequeued during
giveback?
crg_udc_ep_dequeue(ep, req1)
ep->ep_state = EP_STATE_STOPPED
ep->dequeue_paused = true
crg_udc_req_done(ep, req1, -ECONNRESET)
spin_unlock(&crg_udc->udc_lock)
usb_gadget_giveback_request()
req1->complete()
usb_ep_dequeue(ep, req2)
crg_udc_ep_dequeue(ep, req2)
old_ep_state == EP_STATE_STOPPED
goto recover <-- schedules controller reset
When req2 already has first_trb set on the stopped ring, the inner
crg_udc_ep_dequeue() sees old_ep_state == EP_STATE_STOPPED without checking
udc_ep_ptr->dequeue_paused, marks halt_failed = true, and schedules a full
controller reset that drops the USB connection.
> + p_ep_cx = &crg_udc->p_epcx[dci - 2];
> + deq_pt_lo = le32_to_cpu(p_ep_cx->dw2) & EP_CX_TR_DQPT_LO_MASK;
> + deq_pt_hi = le32_to_cpu(p_ep_cx->dw3);
> + dq_pt_addr = (u64)deq_pt_lo | ((u64)deq_pt_hi << 32);
> + pause_pt = crg_udc_tran_trb_dma_to_virt(udc_ep_ptr, dq_pt_addr);
> + if (!pause_pt) {
> + ret = -EIO;
> + goto recover;
> + }
> +
> + if (crg_udc_is_pointer_less_than(pause_pt, udc_req->first_trb,
> + udc_ep_ptr)) {
> + crg_udc_squeeze_xfer_ring(udc_ep_ptr, udc_req);
> + /* Give back the cancelled request BEFORE scheduling the tail:
> + * its callback may add/remove requests, and dropping udc_lock
> + * while traversing the old list is unsafe.
> + */
> + crg_udc_req_done(udc_ep_ptr, udc_req, -ECONNRESET);
> + } else if (udc_req->last_trb &&
> + crg_udc_is_pointer_less_than(udc_req->last_trb, pause_pt,
> + udc_ep_ptr)) {
> + crg_udc_req_done(udc_ep_ptr, udc_req, -ECONNRESET);
> + } else {
[Severity: High]
Does the else-if branch leave udc_ep_ptr->deq_pt stuck at udc_req->first_trb
when pause_pt has already advanced past udc_req->last_trb?
When hardware has consumed the TD's TRBs and its Transfer Event is still
pending on the event ring, crg_udc_req_done() unlinks udc_req from
udc_ep_ptr->queue and unmaps udc_req->bounce with usb_req.actual still 0
(discarding received OUT data). When crg_udc_handle_xfer_event() later
processes the pending event, is_request_dequeued() sees that udc_req is no
longer on the queue and returns before calling crg_udc_update_dequeue_pt().
That leaks the request's TRB slots in crg_udc_room_on_ring(), and if the
endpoint is later halted and unhalted at High or Full Speed,
crg_udc_ep_halt() calls crg_udc_epcx_update_dqptr() and reprograms the
hardware dequeue pointer back to the unmapped TRBs.
[ ... ]
> +static int crg_udc_ep_disable(struct usb_ep *ep)
> +{
[ ... ]
> + if (udc_ep->ep_state == EP_STATE_DISABLED) {
> + /*
> + * A reset can mark this endpoint disabled before reaching its
> + * queue. A callback from another endpoint may disable it now.
> + * Give back its requests before returning success.
> + */
> + crg_udc_ep_nuke(udc_ep, -ESHUTDOWN);
> + udc_ep->desc = NULL;
> + udc_ep->comp_desc = NULL;
> + udc_ep->usb_ep.enabled = false;
> + ret = 0;
> + goto out;
> + }
[Severity: Low]
Should this path clear udc_ep->desc, udc_ep->comp_desc, and
crg_udc->p_epcx[udc_ep->dci - 2] before calling crg_udc_ep_nuke()?
When crg_udc_reinit() disables endpoints for a bus reset with notify_reset
set, it preserves desc, comp_desc, usb_ep.enabled, and p_epcx for the
gadget's usb_ep_disable() call. Taking this early branch leaves p_epcx
unzeroed (since crg_udc_reset_work() skips endpoints once usb_ep.enabled is
false) and exposes non-NULL descriptors while crg_udc_ep_nuke() drops
udc_lock for request givebacks.
[ ... ]
> + if (!crg_udc->num_enabled_eps &&
> + crg_udc->device_state == USB_STATE_CONFIGURED)
> + crg_udc->device_state = USB_STATE_ADDRESS;
[Severity: Medium]
Should disabling the last non-EP0 endpoint downgrade crg_udc->device_state
to USB_STATE_ADDRESS when the USB configuration is still active?
If a configured gadget disables all data endpoints (for example, when
switching an interface to alternate setting 0), the device is still in the
Configured state until SET_CONFIGURATION(0) or a bus reset occurs.
Setting USB_STATE_ADDRESS here causes getstatusrequest() and
setfeaturesrequest() to stall valid Configured-state control requests, and
causes crg_udc_handle_port_status() to see was_configured == false on a
subsequent bus reset and skip usb_gadget_udc_reset().
[ ... ]
> +static int crg_udc_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
> + gfp_t gfp_flags)
> +{
[ ... ]
> + if (udc_ep_ptr->ep_state != EP_STATE_RUNNING) {
> + status = 0;
> + } else if (!list_empty(&udc_ep_ptr->queue)) {
> + struct crg_udc_request *tail;
> +
> + tail = list_last_entry(&udc_ep_ptr->queue,
> + struct crg_udc_request, queue);
> + status = (!tail->all_trbs_queued ||
> + udc_ep_ptr->tran_ring_full) ? 0 :
> + crg_udc_build_td(udc_ep_ptr, udc_req_ptr);
> + } else if (udc_ep_ptr->tran_ring_full) {
> + status = 0;
> + } else {
> + status = crg_udc_build_td(udc_ep_ptr, udc_req_ptr);
> + }
> +
> + if (!status) {
> + list_add_tail(&udc_req_ptr->queue, &udc_ep_ptr->queue);
> + goto out_locked;
> + }
> + spin_unlock_irqrestore(&crg_udc->udc_lock, flags);
> +
> +unmap:
> + crg_udc_unmap_request(udc_ep_ptr, udc_req_ptr, 0);
[Severity: Medium]
When crg_udc_build_td() returns -EBUSY or -ENOSPC, should crg_udc_ep_queue()
set tran_ring_full = true and keep the request on udc_ep_ptr->queue instead
of unmapping and failing it?
On an isochronous endpoint with fewer free ring slots than td_trbs,
crg_udc_queue_trbs() returns -EBUSY without setting tran_ring_full.
Similarly, crg_udc_ep_dequeue() clears tran_ring_full = false before calling
crg_udc_queue_pending_trbs(), which returns 0 without calling
crg_udc_build_td() if all queued requests already have all_trbs_queued or
td_pending set; the next crg_udc_ep_queue() call on that full ring then
invokes crg_udc_build_td() and fails with -ENOSPC. All other callers of
crg_udc_build_td() treat -ENOSPC and -EBUSY as ring-full conditions that
defer the request.
[ ... ]
> +void crg_udc_port_retry_work(struct work_struct *work)
> +{
> + struct crg_gadget_dev *crg_udc =
> + container_of(to_delayed_work(work), struct crg_gadget_dev,
> + port_retry_work);
> + unsigned long flags;
> + int ret;
> +
> + spin_lock_irqsave(&crg_udc->udc_lock, flags);
> + if (!crg_udc->port_reset_pending && !crg_udc->deferred_port_events)
> + goto out;
> + if (crg_udc->resetting || crg_udc->suspended ||
> + crg_udc->shutting_down || !crg_udc->pullup_on ||
> + !crg_udc->gadget_driver || !crg_udc->async_callbacks)
> + goto out;
> + /* Reset work replays deferred events after the callback. A controller
> + * reconstruction is different: retry once its register state is stable.
> + */
> + if (crg_udc->controller_recovering) {
> + mod_delayed_work(system_wq, &crg_udc->port_retry_work,
> + msecs_to_jiffies(CRG_PORT_RESET_RETRY_MS));
> + goto out;
> + }
> + if (crg_udc->port_reset_pending &&
> + crg_udc->port_reset_retry_count++ >= CRG_PORT_RESET_MAX_RETRIES) {
> + bool notify_reset = crg_udc->device_state == USB_STATE_CONFIGURED;
> +
> + dev_err(crg_udc->dev,
> + "port reset did not become ready; resetting controller\n");
> + ret = crg_udc_recover_port_failure(crg_udc, &flags,
> + notify_reset);
> + if (ret != -ECONNRESET)
> + dev_err(crg_udc->dev,
> + "port-reset recovery returned %d\n", ret);
> + goto out;
> + }
> + ret = crg_udc_handle_port_status(crg_udc, &flags);
> + if (ret && ret != -ECONNRESET)
> + dev_dbg(crg_udc->dev, "port reset poll: %d\n", ret);
> +out:
> + spin_unlock_irqrestore(&crg_udc->udc_lock, flags);
> +}
[Severity: Medium]
Can a port reset poll be permanently lost if crg_udc_port_retry_work() runs
while crg_udc->reset_callback_active is true?
kworker (udc_reset_work) kworker (port_retry_work)
crg_udc_reset_work()
reset_callback_active = true
spin_unlock(&udc_lock)
usb_gadget_udc_reset()
crg_udc_port_retry_work()
crg_udc_handle_port_status()
portsc_val & W1C_MASK == 0
if (reset_callback_active)
deferred_port_events |= 0
return 0
spin_lock(&udc_lock)
reset_callback_active = false
if (deferred_port_events) <-- false; port_reset_pending stays true
Because CRG_U3DC_PORTSC_PRC was already W1C-cleared when port_reset_pending
was first set, crg_udc_handle_port_status() sees no new W1C bits during
reset_callback_active and returns early without rescheduling
port_retry_work. crg_udc_reset_work() then only checks
deferred_port_events, leaving port_reset_pending stuck true and blocking EP0
setup handling, endpoint enablement, and request queueing. In addition, if
port_reset_retry_count reaches CRG_PORT_RESET_MAX_RETRIES while
reset_callback_active is true, crg_udc_port_retry_work() runs
crg_udc_recover_port_failure() concurrently with usb_gadget_udc_reset().
[ ... ]
> +int crg_udc_handle_port_status(struct crg_gadget_dev *crg_udc,
> + unsigned long *flags)
> +{
[ ... ]
> + if (crg_udc->device_state >= USB_STATE_DEFAULT) {
[ ... ]
> + reinit_ret = crg_udc_reinit(crg_udc, notify_reset);
[ ... ]
> + }
> +
> + crg_udc->gadget.speed = speed;
> +
> + ret = crg_udc_update_ep0_maxpacketsize(crg_udc);
> + if (ret) {
> + dev_err(crg_udc->dev,
> + "failed to configure EP0 maxpacket: %d\n", ret);
> + return crg_udc_recover_port_failure(
> + crg_udc, flags,
> + crg_udc->bus_reset_pending ||
> + crg_udc->device_state == USB_STATE_CONFIGURED);
> + }
> +
> + crg_udc->connected = 1;
> +
> + if (crg_udc->device_state < USB_STATE_RECONNECTING)
> + crg_udc_enable_setup(crg_udc);
> + }
> + }
[Severity: High]
Does crg_udc->device_state remain stuck in USB_STATE_RECONNECTING when a
port reset completes via crg_udc_port_retry_work() or crg_udc_reset_work(),
or after a link drop with VBUS present?
When device_state >= USB_STATE_DEFAULT, crg_udc_reinit() sets device_state
to USB_STATE_RECONNECTING, so crg_udc_handle_port_status() skips
crg_udc_enable_setup() expecting the caller to drain the event ring and call
crg_udc_prepare_for_setup(). Neither crg_udc_port_retry_work() nor
crg_udc_reset_work() calls crg_udc_prepare_for_setup() after
crg_udc_handle_port_status(), and the link-drop path (cable_connected &&
!ccs_drop_ignore) also calls crg_udc_reinit() with connected = 0 so a later
CSC/PEC/PPC reconnect skips crg_udc_enable_setup() as well.
Also, while port_reset_pending is true before crg_udc_reinit() runs,
device_state is not yet USB_STATE_RECONNECTING; if a new SETUP event arrives
before port_retry_work polls PED, crg_udc_handle_event() dispatches it to
crg_udc_handle_setup_pkt(), which sets ep0_state = EP0_STATE_ABORTING and
returns early on port_reset_pending, dropping the SETUP packet and wedging
EP0.
[ ... ]
> +int crg_udc_ep_halt(struct crg_udc_ep *udc_ep_ptr, int halt, int ignore_wedge,
> + unsigned long *flags)
> +{
[ ... ]
> + if (udc_ep_ptr->dci == 0) {
> + /* EP0 stalls with a STATUS-stage TRB, not SET_HALT. */
> + if (!halt)
> + return -EOPNOTSUPP;
> +
> + return crg_udc_set_ep0_halt(crg_udc);
> + }
[Severity: Medium]
Does this break USB_REQ_SET_FEATURE and USB_REQ_CLEAR_FEATURE(ENDPOINT_HALT)
targeting EP0 in setfeaturesrequest()?
drivers/usb/gadget/udc/crg/crg-udc-ep0.c:setfeaturesrequest() {
...
udc_ep_ptr = &crg_udc->udc_ep[dci];
status = crg_udc_ep_halt(
udc_ep_ptr, (b_request == USB_REQ_SET_FEATURE) ? 1 : 0,
0, flags);
if (status < 0)
goto set_feature_error;
...
crg_udc->setup_status = STATUS_STAGE_XFER;
crg_udc_submit_ep0_status(crg_udc, status, 0);
}
On CLEAR_FEATURE(USB_ENDPOINT_HALT) for EP0, returning -EOPNOTSUPP causes
setfeaturesrequest() to stall EP0 instead of completing the status stage.
On SET_FEATURE(USB_ENDPOINT_HALT) for EP0, crg_udc_set_ep0_halt() queues a
STALL status TRB using crg_udc->status_req, sets ep_state = EP_STATE_HALTED,
and returns 0; setfeaturesrequest() then calls crg_udc_submit_ep0_status() a
second time, which fails on the halted endpoint and sets ep0_state =
EP0_STATE_ERROR so crg_udc_handle_xfer_event() ignores the STALL completion.
[ ... ]
> + if (recovering || crg_udc->gadget.speed >= USB_SPEED_SUPER) {
> + udc_ep_ptr->deq_pt = udc_ep_ptr->enq_pt;
> + udc_ep_ptr->tran_ring_full = false;
> + }
> + udc_ep_ptr->ep_state = EP_STATE_HALTED;
> + /*
> + * A failed stop retained old DMA mappings even at HS/FS.
> + * After a confirmed retry, all those requests can be given back.
> + */
> + if (recovering || crg_udc->gadget.speed >= USB_SPEED_SUPER)
> + crg_udc_ep_nuke(udc_ep_ptr, -ECONNRESET);
> + } else if (do_halt == 0) {
> + /* clearing ep halt state */
> + /* reset sequence number */
> + if (crg_udc_issue_command(crg_udc, CRG_CMD_RESET_SEQNUM, param0,
> + 0))
> + return -EIO;
> +
> + if (!reset_seq_only) {
> + /* Clear halt for a halted EP. */
> + /* NOTE: we must CLEAR_HALT first,
> + * then SET_TR_DQPTR
> + */
> + ret = crg_udc_issue_command(crg_udc,
> + CRG_CMD_CLEAR_HALT, param0, 0);
> + if (ret)
> + goto clear_halt_failed;
> + ret = crg_udc_epcx_update_dqptr(udc_ep_ptr);
> + if (ret)
> + goto clear_halt_failed;
> + }
[Severity: Medium]
Can clearing a halt at High or Full Speed rewind the hardware dequeue
pointer to the start of a partially completed multi-TRB request?
Chained TRBs before the final TRB of a TD have ioc = false, so hardware
advances TR_DQPT in p_epcx as each TRB completes while udc_ep_ptr->deq_pt
remains at first_trb. At High or Full Speed, halting the endpoint retains
the in-flight request without updating udc_ep_ptr->deq_pt, and clearing the
halt then calls crg_udc_epcx_update_dqptr(), overwriting the hardware
dequeue pointer with udc_ep_ptr->deq_pt and re-transferring the already
completed TRBs.
[ ... ]
> +static int crg_udc_stop_error_ep(struct crg_gadget_dev *crg_udc, u8 dci)
> +{
[ ... ]
> + /* The controller is no longer reading request buffers. */
> + udc_ep_ptr->halt_failed = false;
> + udc_ep_ptr->deq_pt = udc_ep_ptr->enq_pt;
> + udc_ep_ptr->tran_ring_full = false;
> + udc_ep_ptr->ep_state = isoc ? EP_STATE_STOPPED : EP_STATE_HALTED;
> +
> + crg_udc_ep_nuke(udc_ep_ptr, -ECONNRESET);
> +
> + return 0;
[Severity: High]
Does setting ep_state = EP_STATE_STOPPED here permanently wedge isochronous
endpoints after any transfer error event?
With ep_state == EP_STATE_STOPPED and dequeue_paused == false,
crg_udc_ep_can_queue() returns false and crg_udc_ep_queue() rejects all
subsequent requests with -ESHUTDOWN. Unlike bulk and interrupt endpoints,
crg_udc_ep_halt() rejects isochronous endpoints with -EOPNOTSUPP, and
udc_ep_ptr->deq_pt is advanced to enq_pt in software without calling
crg_udc_epcx_update_dqptr(), leaving no way for the gadget to resume the
isochronous stream without disabling and re-enabling the endpoint.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261116-axiado-ax3000-usb-device-controller-v5-0-49271ed5c793@axiado.com?part=5
next prev parent reply other threads:[~2026-11-16 20:47 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 [this message]
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
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-217676@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.