net: dsa: mxl862xx: devlink flash and rescue
Subsystems (7)
Daniel Golle
maintainerv15 cover net: dsa: mxl862xx: devlink flash and rescue
This series adds "devlink dev flash" and "devlink dev info" support to the MaxLinear MxL862xx DSA driver, and makes a switch stuck in its MCUboot loader recoverable through the same path.
The switch is flashed over the loader's clause-22 SMDIO download interface after the firmware API has rebooted it into MCUboot, and the driver reinitialises through a deferred detach and re-probe once the new image runs. A switch found in MCUboot at probe registers in a reduced rescue mode with firmware version 0.0.0, so the same flash flow recovers it; an interrupted download is drained in the background first. The deferred re-probe comes from a new driver-core helper, device_schedule_reprobe(), since a driver-owned work item can neither survive a racing rmmod nor synchronise its detach with device_shutdown(). fwupd's devlink plugin carries the matching quirks [17].
Tested on an MxL86252C switch of the BananaPi R4 Pro 8X: repeated flash cycles, recovery of a download interrupted by a crash, and a flash after a hard reset into the loader. The helper was runtime-tested on Intel AX101 with PROVE_LOCKING and DEBUG_OBJECTS_WORK [11].
Changes since v14 [19]:
- patch 3: skip the detach while probing is blocked, which device_shutdown() does before its walk reaches any device, instead of a per-device flag set only once the walk arrives; validate the device and snapshot the parent, its locking requirement and the bound driver under the device lock; keep -EPROBE_DEFER out of the re-probe error path so it cannot overwrite a deferred probe reason (all found by Sashiko AI review)
- patch 4: treat the closing END write as advisory, since the loader has verified the image by then, and admit only the flash task's own firmware reads past block_host instead of every read from every context (found by Sashiko AI review)
- patch 5: classify a status register left in the download handshake as a loader needing a power cycle rather than as running firmware, give the loader one step to publish its next state before ruling it out after a failed clause-45 wait, abort the drain polls as soon as teardown asks for it instead of stalling unbind for up to 17 s, and pair the rescue_mode accesses with WRITE_ONCE()/READ_ONCE() (all found by Sashiko AI review)
- patch 6: asic.rev comes from the CHIP ID registers as well, and -EIO means the driver gave up on the recovery, which may need a rebind rather than a power cycle (found by Sashiko AI review)
- Andrew's Reviewed-by is kept on patches 1, 2, 4 and 6; the changes to 4 and 6 are the two small ones above and a documentation reword
- the same review asks again whether patch 1 should install .flash_update only for drivers implementing the callback, as v4 did; it stays unconditional as Andrew asked in v9. Its remaining findings are not acted on either: the pre-existing window in __device_release_driver() where a ->shutdown() can interleave with a release, which every unbind path shares; the recorded driver pointer, which an unbind and rebind within the delay can match again at the cost of one spurious re-probe; and the get_stats64() re-arm race in remove(), which predates this series and is fixed separately for net
- the changes to patches 3 to 6 were written with an LLM coding assistant working from the Sashiko findings and reviewed by hand; the Assisted-by tags on those patches record this
Changes since v13 [18]:
- patch 5: initialise the SerDes state once mxl862xx_wait_ready() has cached the firmware version, still before the rescue-mode early return, so PCS setup can depend on the running firmware
- picked up Andrew's Reviewed-by on patches 1 and 4; the one on patch 5 is not carried as that patch changed
- the Sashiko review of v13 repeats the ABA finding on patch 3 dismissed in v13 and marks the two __device_release_driver() windows and the get_stats64() re-arm race as pre-existing; no change
- the change to patch 5 was written with an LLM coding assistant working from a report against a downstream tree and reviewed by hand; the Assisted-by tag on that patch records this
Changes since v12 [13]:
- v12 went out just as net-next closed for the 7.3 merge window. The helper of patch 3 was then posted on its own, with conversions of the existing open-coded users in iwlwifi, hci_h5 and btintel_pcie, most recently as v3 [14], which Greg's patch bot deferred past the merge window; Hans de Goede reviewed and tested the helper and the hci_h5 conversion there on RTL8723BS hardware [15][16]. The Sashiko review of that posting found the same issues in the helper as the review of v12 did, so patch 3 here supersedes the helper patch of that series; once this series is merged, the conversions follow as patches for bluetooth-next and wireless-next. On the userspace side, fwupd's devlink plugin has meanwhile gained the quirks for these switches
[17]
- patch 3: queue the re-probe on system_freezable_wq, so one pending across system suspend runs after resume instead of detaching a suspended device or racing its late suspend callbacks; record at scheduling time whether the parent needs locking instead of reading dev->bus, which may be gone with its module once the device was unregistered; let __device_release_driver() report whether it released the driver, so an administrative unbind that wins the race inside the device links loop is not undone by the re-attach (all found by Sashiko AI review); use dev_err_probe() for the re-probe error path (Hans de Goede)
- patch 4: stop the stats poll with disable_delayed_work_sync() in the flash path, so a racing get_stats64() re-arm is a no-op, and drop the early return in the work function; the v12 reordering of remove() is gone as well, since the get_stats64() race it addressed predates this series and needs a fix of its own (found by Sashiko AI review)
- two further findings of the same review are not acted on: the recorded driver pointer could in theory match a different driver loaded at the same address within the delay, which would cost that driver one spurious detach and re-probe; and the final put_device() from the work could call a release() whose module was unloaded in the meantime, which is the same hazard every asynchronous device reference in the core carries, the async probe helper included
- the changes to patches 3 and 4 were written with an LLM coding assistant working from the Sashiko findings and reviewed by hand; the Assisted-by tags on those two patches record this
Changes since v11 [12]:
- patch 3: pin the parent device across the deferred re-probe and take the parent lock across device_attach() on buses that need it; a reference on the child alone left a freed dev->parent dereferenced under __device_driver_lock() (found by Sashiko AI review)
- patch 4: cancel the stats poll after dsa_unregister_switch() so a racing get_stats64() cannot re-arm it against freed priv; and keep the host blocked for writes across the post-flash readiness poll, letting only the flash path's own reads reach the new firmware (found by Sashiko AI review)
Changes since v10 [10]:
- new patch 3: driver core: add device_schedule_reprobe(), as posted in the RFC [11], used to schedule the post-flash and post-drain re-probe with device_schedule_reprobe() instead of a driver-owned work item.
- the dsa_switch allocation returns to devres. Keeping it out of devres only defused the remaining check-vs-detach window, which the core helper closes outright
- scheduling the re-probe is now the one step that can fail after the switch was flashed, since the helper allocates its work item internally and v10's allocate-up-front dance is no longer possible. An -ENOMEM there is a system-wide condition no driver-level message or recovery improves, so flash_update just returns it (unbind and rebind reinitialises the driver), and a drain whose hand-off fails still marks recovery failed so devlink does not keep promising a retry
Changes since v9 [9]:
- Harmonised the SB PDI timeouts. The verify wait is now one constant shared by the flash and drain paths (15 s), the 1-byte mailbox step is another (2 s) used by the drain and by both detection waits, and the per-slice write budget drops from 120 s to 60 s. The last-slice flush, which cannot see the boundary between programming and verifying, gets the sum of the two.
- The post-flash and post-drain reprobe no longer detaches a device that has been shut down or unbound, and the dsa_switch is allocated outside devres so a lost race cannot leave dsa_switch_find() reading freed memory. This was a live bug in v9's patch 3 as well, reachable by rebooting within 500 ms of a flash.
- A failed reprobe hand-off after a successful drain now logs and fails flashing outright, instead of leaving devlink answering "retry shortly" for good. Dropped heal_lock and mxl862xx_stop_work() with
it: the lock only made the flag test and the queueing atomic, which is not the guarantee the comment claimed, and the reprobe's own check is what actually decides now.
- A loader that publishes READY but never services the register-read challenge now reports -ENXIO rather than propagating -ETIMEDOUT, and the documented return sets of mxl862xx_rescue_mode_detect() and mxl862xx_rescue_drain_finish() match what the code returns.
- Commit message for patch 4 no longer claims a running firmware is "left untouched" (the presence probe writes two mailbox scratch registers, inert to a firmware that does not read them), says that an SB PDI window away from the OTP reset offsets also yields -ENODEV, and describes the -ENXIO outcome above.
- Commented why STAT == 0 during a drain is unambiguous: by the r_remain == 0 rule the loader cannot be both inside the receive loop asking for a chunk and publishing a verdict.
- Documented that a switch power cycled on its own needs the driver unbound and rebound before a failed recovery is re-examined.
Changes since v8 [8]:
- install the flash_update devlink op unconditionally and return -EOPNOTSUPP from the trampoline for drivers without the callback, instead of a second devlink_ops permutation (Andrew Lunn)
- picked up Andrew's Reviewed-by on patches 2 and 5, given on v5
Changes since v7 [7]:
- most of the changes below address findings of the Sashiko AI reviews of v7
- the MCUboot loader's transfer completion was reverse-engineered to settle two of them: it publishes an image verification verdict in its status register, finalises without the END magic once a 2 s timeout expires, and keeps the host's byte count visible while it programs a chunk. The interrupted-download drain therefore no longer sends END, which a loader still in its receive loop consumes as a byte count and underflows its receive counter on, and the flash path now reports a rejected image instead of a write timeout
- refuse a second devlink dev flash while the previous one's reprobe is still pending, and stop publishing a zeroed firmware version after a failed transfer
- initialise the SerDes state before the rescue-mode early return, so a successful rescue-mode flash cannot hand phylink an unconfigured PCS
- do not fail probe from the wedged-download branch of the rescue detection, which a download interrupted with exactly one byte outstanding would trigger, and report a failed recovery through devlink rather than refusing every flash for good
- reset the SB PDI mailbox before probing it, log the drain's progress, and correct the protocol and register comments throughout
Changes since v6 [6]:
- reprobe from a single delayed work item instead of a kthread spawned by a workqueue kickoff; the kthread existed only to drop the module reference from core code, but its creation-failure path did the racy module_put() from module text anyway and could strand the driver bound with skip_teardown set. The collapsed form matches iwl_trans_reprobe_wk(), and a failed reprobe now leaves the device unbound like a failed probe
- only signal END on a successful transfer; a failure leaves the loader mid-payload, where END is read as a byte count and can underflow the receive counter, so return the error and let the reprobe recover
- add cond_resched() to the payload loop so a long transfer over a bit-banged MDIO bus under CONFIG_PREEMPT_NONE does not trip the soft-lockup detector
- drop the cached firmware version and chip id on a failed flash so devlink dev info stops reporting the pre-flash version until the reprobe
- report the firmware version under DEVLINK_INFO_VERSION_GENERIC_FW instead of a bare "fw" string
- correct the SB PDI header comment's SMDIO register map and expand the note on why closing the shared conduit is safe
Changes since v5 [5]:
- run the post-flash reprobe from a kthread that drops the module reference with module_put_and_kthread_exit() from core code, fixing a use-after-free where a work item's trailing module_put() could return into module text a racing rmmod had freed; a workqueue kickoff spawns the kthread off the devlink caller where kthread_create() can return -EINTR
- send END on every flash failure from the ready handshake onward so an aborted transfer lets MCUboot reboot instead of leaving it waiting
- after the background drain finalises an interrupted download, reprobe and let the probe-time detection re-classify the switch, so a valid image a last-moment interruption left bootable comes up as running firmware; rescue_drain() no longer inspects or reports the outcome
- re-read the SB PDI status register once more after a poll timeout expires, so a preempted poll cannot report a spurious -ETIMEDOUT
- bail out of the periodic stats poll when the flash teardown has set WORK_STOPPED, closing a get_stats64() re-arm race
- allocate the reprobe kickoff before disturbing the switch, so an -ENOMEM cannot leave it flashed but never reprobed
- omit asic.id/asic.rev when the CHIP ID read returned 0, instead of publishing a bogus "0000" for fwupd to match firmware against
- treat the flashless-download loop (STAT 0xc33c) as an unsupported configuration and fail probe with -ENODEV instead of advertising it as flashable
Changes since v4 [4]:
- report the numeric chip part number and version read from the static CHIP ID registers as the "asic.id" and "asic.rev" fixed versions instead of a model-name string, which does not belong in a devlink version identifier (Jakub Kicinski)
- report the running firmware version as the "stored" version too, since the switch boots it from its own flash, so userspace can distinguish a flash-backed part from a flashless one by the presence of "stored" without a future API change
- run the post-flash reprobe from a self-contained work item again instead of the v4 kernel thread, which tripped the hung-task watchdog while parked across the flash and returned -EINTR from kthread_create() when the devlink command was interrupted
- re-read the new firmware version through the reprobe's fresh probe and drop the SYS_MISC_FW_VERSION exemption from the host block
- raise the firmware command poll timeout so the FW_UPDATE command that reboots into MCUboot is not cut short
- detect the switch state from the value MCUboot publishes in the SB PDI STAT register (loader ready, wedged download, or running firmware), confirming a live console loader with a register-read challenge, instead of trusting a bare SMDIO scratch write
- fail probe with -ENODEV over SB PDI when the switch does not respond at all (absent, unpowered, or misdescribed in the device tree) instead of letting the clause-45 API flood the log with CRC errors
- drain a wedged interrupted download back to a clean ready state from a background work item so the multi-minute recovery never holds the devlink instance lock, reporting no firmware version and refusing flash with -EBUSY until it completes
- report the rescue-mode null firmware version "0.0.0" as both the running and stored version, matching the running/stored reporting above
- split the devlink documentation into its own patch and add Documentation/networking/devlink/mxl862xx.rst describing the info versions and the flash update behaviour (Jakub Kicinski)
- include example "devlink dev info" outputs in the commit messages of patches 3 and 4 (Jakub Kicinski)
Changes since v3 [3]:
- only install the flash_update devlink op for switches whose driver implements it, so the devlink core rejects unsupported requests before fetching the firmware file from userspace
- run the deferred reprobe from a kernel thread which ends in module_put_and_kthread_exit() instead of a work item that dropped its module reference while still executing module code
- fail firmware API read commands with -ENODEV after the update has finished instead of faking success with an unfilled buffer, which could send port_fdb_dump() into an endless loop
- keep the host block in place across the post-update version query by exempting SYS_MISC_FW_VERSION from block_host instead of briefly lifting the block, and write all blocking flags under the MDIO bus lock
- check the return value of all SB PDI control writes; a failed address write during the half-bank switch could otherwise place the second half of the payload at the wrong flash offset
- initialise the progress notification deadline from jiffies so notifications are not suppressed on 32-bit systems shortly after boot
- log a distinct diagnostic when rescue mode detection fails on an SMDIO bus error instead of silently treating it as not being in rescue mode
- flush the switchdev deferred queue after closing the ports so the bridge's deferred STP DISABLED transitions reach the firmware while it is still running instead of failing against the host block with "failed to set STP state" errors
- treat -ENODEV as successful deletion in port_mdb_del() so the post-update teardown no longer leaves host MDB entries behind for the DSA core to report when the tree is torn down
Changes since v2 [2]:
- validate the firmware image, including both CRCs, before taking down any ports, so that a malformed file is rejected without disturbing the running switch and without the needless flash and reprobe cycle it previously triggered
- reject images whose declared payload sizes overflow when summed (check_add_overflow) or sum up to zero; the latter previously erased the flash without writing anything back
- allocate the reprobe work item and take the module and device references before starting the update, so scheduling the reprobe can no longer fail after the switch has been pushed into MCUboot
- prevent the stats poll work from being re-armed and cancel the CRC error work before starting the transfer
- check the host-blocking flags in mxl862xx_api_wrap() under the MDIO bus lock to close the race window where an API command which had already passed the check could reach the bus after the switch rebooted into MCUboot
- check the return value of SB PDI data word writes so a failed MDIO transaction aborts the transfer instead of being noticed only through a corrupted image
- report a per-model chip name (e.g. "MaxLinear MxL86252") as the devlink "asic.id" fixed version instead of the devicetree compatible string, whose comma is awkward for userspace consumers such as fwupd (see discussion on v2 patch 3)
- report the canonical null version "0.0.0" instead of "mcuboot-rescue" as the running firmware version in rescue mode, so that version-comparing update tools like fwupd treat every available release as an upgrade and offer it for recovery
Changes since RFC [1]:
- detect a switch stuck in MCUboot rescue mode at probe, register the switch without any ports and report "mcuboot-rescue" as the running firmware version, so devlink flash can recover from a failed or interrupted update (Andrew Lunn)
- clarify in the commit message of patch 2 that the per-transaction MDIO bus locking is about other, non-switch devices on the same MDIO bus (Andrew Lunn)
- mention in the commit message of patch 3 that closing the ports also stops phylib from polling the switch-internal PHYs during the transfer (Andrew Lunn)
- split up run-on sentence and explain the dynamically allocated reprobe work item instead of just pointing at iwlwifi in the commit message of patch 3 (Manuel Ebner)
- use kzalloc_obj() (Manuel Ebner)
- state the actual duration of a complete flash and reprobe cycle (just under a minute) in comments and the commit message, and clarify that the timeout values are generous upper bounds (Manuel Ebner)
[1] https://lore.kernel.org/all/[email protected]/
[2] https://lore.kernel.org/all/[email protected]/
[3] https://lore.kernel.org/all/[email protected]/
[4] https://lore.kernel.org/all/[email protected]/
[5] https://lore.kernel.org/all/[email protected]/
[6] https://lore.kernel.org/all/[email protected]/
[7] https://lore.kernel.org/all/[email protected]/
[8] https://lore.kernel.org/all/[email protected]/
[9] https://lore.kernel.org/all/[email protected]/
[10] https://lore.kernel.org/all/[email protected]/
[11] https://lore.kernel.org/all/[email protected]/
[12] https://lore.kernel.org/all/[email protected]/
[13] https://lore.kernel.org/all/[email protected]/
[14] https://lore.kernel.org/all/[email protected]/
[15] https://lore.kernel.org/all/[email protected]/
[16] https://lore.kernel.org/all/[email protected]/
[17] https://github.com/fwupd/fwupd/commit/e50c9e5ab39d31242e664efbbf441fd46d15a0cd
[18] https://lore.kernel.org/all/[email protected]/
[19] https://lore.kernel.org/all/[email protected]/
Daniel Golle (6):
net: dsa: add devlink flash_update callback to dsa_switch_ops
net: dsa: mxl862xx: add SMDIO clause-22 register access driver core: add device_schedule_reprobe()
net: dsa: mxl862xx: add devlink flash_update and info_get
net: dsa: mxl862xx: recover switch stuck in MCUboot rescue mode
net: dsa: mxl862xx: document devlink flash and info support
Documentation/networking/devlink/index.rst | 1 + Documentation/networking/devlink/mxl862xx.rst | 81 ++ MAINTAINERS | 1 + drivers/base/dd.c | 126 +- drivers/net/dsa/mxl862xx/Makefile | 2 +- drivers/net/dsa/mxl862xx/mxl862xx-api.h | 10 + drivers/net/dsa/mxl862xx/mxl862xx-cmd.h | 2 + drivers/net/dsa/mxl862xx/mxl862xx-fw.c | 1101 +++++++++++++++++ drivers/net/dsa/mxl862xx/mxl862xx-fw.h | 20 + drivers/net/dsa/mxl862xx/mxl862xx-host.c | 65 + drivers/net/dsa/mxl862xx/mxl862xx-host.h | 2 + drivers/net/dsa/mxl862xx/mxl862xx-phylink.c | 2 + drivers/net/dsa/mxl862xx/mxl862xx.c | 153 ++- drivers/net/dsa/mxl862xx/mxl862xx.h | 37 + include/linux/device.h | 2 + include/net/dsa.h | 3 + net/dsa/devlink.c | 13 + 17 files changed, 1605 insertions(+), 16 deletions(-) create mode 100644 Documentation/networking/devlink/mxl862xx.rst create mode 100644 drivers/net/dsa/mxl862xx/mxl862xx-fw.c create mode 100644 drivers/net/dsa/mxl862xx/mxl862xx-fw.h
base-commit: 31f961de2f90fbf52eb2d4e15b3eeaa09f9b4fc2
prerequisite-patch-id: 0000000000000000000000000000000000000000
Signature · 1 line
2.55.0
Daniel Golle
maintainerPATCH v15 1/6 net: dsa: add devlink flash_update callback to dsa_switch_ops
Add a devlink_flash_update callback to dsa_switch_ops so that DSA drivers can support devlink dev flash without open-coding the devlink plumbing. Like the other trampolines in net/dsa/devlink.c, the op returns -EOPNOTSUPP when the driver does not implement the callback; the devlink core will then have fetched the firmware file from userspace before the request fails, which is acceptable for an operation as infrequent as a firmware update.
The devlink core calls the op with the devlink instance lock held and without rtnl_lock, whereas DSA serialises its switch and port ops under rtnl_lock, so a driver has to serialise a flash against its own ops itself.
---
v15: no changes
v14: no changes, picked up Andrew's v13 Reviewed-by
v13: no changes
v12: no changes
v11: no changes
v10: no changes
v9: install the flash_update op unconditionally and return -EOPNOTSUPP
from the trampoline like the other DSA devlink trampolines, instead of a second devlink_ops permutation (Andrew Lunn)
v8:
- retitled: this patch adds the callback, its first user is patch 3
- describe the op's calling context in the commit message
v7: no changes
v6: no changes
v5: no changes
v4: only install the flash_update op for drivers implementing the
callback so the devlink core keeps rejecting unsupported flash requests before fetching the firmware file
v3: no changes
v2: align continuation lines with the open parenthesis
include/net/dsa.h | 3 +++ net/dsa/devlink.c | 13 +++++++++++++ 2 files changed, 16 insertions(+)
include/net/dsa.h +3 -0
@@ -1174,6 +1174,9 @@ struct dsa_switch_ops {int (*devlink_info_get)(struct dsa_switch *ds,struct devlink_info_req *req,struct netlink_ext_ack *extack); +int (*devlink_flash_update)(struct dsa_switch *ds, +struct devlink_flash_update_params *params, +struct netlink_ext_ack *extack);int (*devlink_sb_pool_get)(struct dsa_switch *ds,unsigned int sb_index,u16 pool_index,struct devlink_sb_pool_info *pool_info);
net/dsa/devlink.c +13 -0
@@ -20,6 +20,18 @@ static int dsa_devlink_info_get(struct devlink *dl,return -EOPNOTSUPP ; } +static int dsa_devlink_flash_update (struct devlink *dl, +struct devlink_flash_update_params *params, +struct netlink_ext_ack *extack) +{ +struct dsa_switch *ds =dsa_devlink_to_ds (dl); + +if (!ds->ops->devlink_flash_update) +return -EOPNOTSUPP ; + +return ds->ops->devlink_flash_update (ds, params, extack); +} +static int dsa_devlink_sb_pool_get (struct devlink *dl,unsigned int sb_index,u16 pool_index,struct devlink_sb_pool_info *pool_info)
@@ -169,6 +181,7 @@ dsa_devlink_sb_occ_tc_port_bind_get(struct devlink_port *dlp,static const struct devlink_ops dsa_devlink_ops = { .info_get = dsa_devlink_info_get, + .flash_update = dsa_devlink_flash_update, .sb_pool_get = dsa_devlink_sb_pool_get, .sb_pool_set = dsa_devlink_sb_pool_set, .sb_port_pool_get = dsa_devlink_sb_port_pool_get,
Signature · 1 line
2.55.0
Daniel Golle
maintainerPATCH v15 2/6 net: dsa: mxl862xx: add SMDIO clause-22 register access
In reply to Daniel GolleAdd mxl862xx_smdio_read() and mxl862xx_smdio_write() for clause-22 SMDIO register access. The switch's MCUboot bootloader exposes only clause-22 registers; the clause-45 MMD interface needs the running firmware and is unavailable while the switch is in MCUboot. The MDIO bus lock is held per-transaction (not across polls) so that SB PDI polling during flash erase does not starve other non-switch users of the same MDIO bus, such as separate PHYs providing WAN or management interfaces.
Unlike mxl862xx_api_wrap(), which takes the bus lock with MDIO_MUTEX_NESTED because it can be entered from the accessors of the switch-internal MDIO bus while that bus's lock of the same lock class is already held, the SMDIO helpers take it with a plain mutex_lock(). They are only called from probe and devlink flash contexts where no other MDIO bus lock can be held.
---
v15: no changes
v14: no changes
v13: no changes
v12: no changes
v11: no changes
v10: no changes
v9: no changes, picked up Andrew's v5 Reviewed-by
v8: document the paged register window and the per-transaction bus
locking next to the helpers, rather than only in this changelog (found by Sashiko AI review)
v7: no changes
v6: no changes
v5: no changes
v4: no changes
v3: explain the plain mutex_lock() vs MDIO_MUTEX_NESTED choice in
the commit message
v2: clarify in the commit message that the per-transaction bus
locking is about unrelated non-switch devices on the same MDIO bus (Andrew Lunn)
drivers/net/dsa/mxl862xx/mxl862xx-host.c | 40 ++++++++++++++++++++++++ drivers/net/dsa/mxl862xx/mxl862xx-host.h | 2 ++ 2 files changed, 42 insertions(+)
drivers/net/dsa/mxl862xx/mxl862xx-host.c +40 -0
@@ -495,6 +495,46 @@ int mxl862xx_reset(struct mxl862xx_priv *priv)return ret; } +#define MXL862XX_SMDIO_ADDR_REG 0x1f +#define MXL862XX_SMDIO_PAGE_MASK 0xfff0 +#define MXL862XX_SMDIO_OFF_MASK 0x000f + +/* Paged clause-22 window: the page goes into MII register 0x1f, the low nibble +* of addr selects one of the 16 registers within it. Both helpers take the MDIO +* bus lock per transaction, so callers must not already hold it -- unlike +* mxl862xx_api_wrap(), which holds it across a whole firmware command. +*/ +int mxl862xx_smdio_read (struct mxl862xx_priv *priv,u32 addr) +{ +struct mii_bus *bus = priv->mdiodev->bus; +int phy = priv->mdiodev->addr; +int ret; + +mutex_lock (&bus->mdio_lock); + ret =__mdiobus_write (bus, phy,MXL862XX_SMDIO_ADDR_REG , + addr &MXL862XX_SMDIO_PAGE_MASK ); +if (ret >=0 ) + ret =__mdiobus_read (bus, phy, addr &MXL862XX_SMDIO_OFF_MASK ); +mutex_unlock (&bus->mdio_lock); +return ret; +} + +int mxl862xx_smdio_write (struct mxl862xx_priv *priv,u32 addr,u16 val) +{ +struct mii_bus *bus = priv->mdiodev->bus; +int phy = priv->mdiodev->addr; +int ret; + +mutex_lock (&bus->mdio_lock); + ret =__mdiobus_write (bus, phy,MXL862XX_SMDIO_ADDR_REG , + addr &MXL862XX_SMDIO_PAGE_MASK ); +if (ret >=0 ) + ret =__mdiobus_write (bus, phy, addr &MXL862XX_SMDIO_OFF_MASK , + val); +mutex_unlock (&bus->mdio_lock); +return ret; +} +void mxl862xx_host_init (struct mxl862xx_priv *priv) {INIT_WORK (&priv->crc_err_work, mxl862xx_crc_err_work_fn);
drivers/net/dsa/mxl862xx/mxl862xx-host.h +2 -0
@@ -18,5 +18,7 @@ int mxl862xx_api_wrap(struct mxl862xx_priv *priv, u16 cmd, void *data, u16 size, mxl862xx_api_wrap(dev, cmd, &(data), sizeof((data)), true, true)int mxl862xx_reset (struct mxl862xx_priv *priv); +int mxl862xx_smdio_read (struct mxl862xx_priv *priv,u32 addr); +int mxl862xx_smdio_write (struct mxl862xx_priv *priv,u32 addr,u16 val);#endif /* __MXL862XX_HOST_H */
Signature · 1 line
2.55.0
Daniel Golle
maintainerPATCH v15 3/6 driver core: add device_schedule_reprobe()
In reply to Daniel GolleThree in-tree drivers schedule a deferred re-probe of their own device from a work item whose work function lives in module text: iwlwifi (iwl_trans_schedule_reprobe(), firmware crash recovery when a lighter restart is not sufficient), hci_h5 (h5_btrtl_resume(), RTL devices lose their firmware state over suspend) and btintel_pcie (synchronous device_reprobe() from its own reset work, with a hand-rolled locking contract spanning several comments).
Two bug classes affect the hand-rolled implementations:
1. The work function ends with put_device(); kfree(); module_put(THIS_MODULE); in module text. After the atomic decrement a concurrent rmmod can free the module text before the function epilogue has finished executing. This is exactly the race module_put_and_kthread_exit() exists to close for kthreads; there is no work-item equivalent.
2. There is no synchronization between the deferred device_reprobe() and device_shutdown() or a driver unbind. The drivers do not check any bound state before calling device_reprobe(), so a stale re-probe can undo an administrative unbind, and the detach half can run against a device whose ->shutdown() callback has already run. The core already blocks the attach half during shutdown (device_shutdown() calls device_block_probing() before any callback, and really_probe() honors defer_all_probes), but nothing blocks the detach half. For drivers which clear their drvdata in ->shutdown() so that a subsequent ->remove() becomes a no-op this escalates to use-after-free of driver state which other subsystem structures still reference.
Both classes disappear when the driver core owns the deferred work. Add device_schedule_reprobe(), which schedules a detach and re-probe of a device after a caller-specified delay:
- The work function is builtin text, so callers do not need to hold a module reference. If the driver module is unloaded before the work runs, driver_unregister() has already unbound the device, the bound driver no longer matches the driver recorded at scheduling time and the work does nothing.
- The recorded driver pointer is only ever compared, never dereferenced, so it may legitimately point to freed memory.
- The bound-state check and __device_release_driver() run under a single hold of the device lock and, where the bus needs it, the parent lock, the same lock dance device_release_driver_internal() uses. This closes the check-vs-detach TOCTOU that drivers cannot close themselves, because device_reprobe() takes the device lock internally. __device_release_driver() reports whether this call was the one to release the driver, so an unbind that wins the race while busy consumer links are being unbound is not followed by a re-attach.
- Both @dev and its parent are pinned for the lifetime of the work. The parent, whether it needs locking and the bound driver are recorded under the device lock, which device_del() takes before it drops @dev's reference to the parent. A device that was unregistered before the work runs may have outlived the module providing its bus type, so dev->bus is not read once the work is scheduled.
- The detach half is skipped while probing is blocked, which device_shutdown() does before its walk reaches any device. A re-probe firing during shutdown therefore leaves the device bound, and its ->shutdown() callback still runs.
- The work is queued on system_freezable_wq. A re-probe pending across system suspend therefore runs once the devices have resumed and probing is unblocked again, instead of detaching a device the PM core has already suspended or running concurrently with its late suspend callbacks, which the PM core invokes without the device lock. The attach half is plain device_attach(), which checks the dead flag, and it takes the parent lock on buses that set need_parent_lock, mirroring bus_rescan_devices_helper().
One pre-existing window remains: __device_release_driver() transiently drops the locks while consumer device links are busy, so for devices with busy consumers a ->shutdown() can still interleave in the middle of the release. That window exists identically for every unbind path in the kernel, sysfs unbind included, and is not made worse by this helper.
---
v15:
- skip the detach while probing is blocked instead of adding a per-device shutdown_done flag: device_shutdown() blocks probing before its walk starts, so the flag left a window where the work detached a device that then neither re-attached nor got its ->shutdown() call (found by Sashiko AI review)
- validate the device and snapshot the parent, its locking requirement and the bound driver under the device lock, so an unregister racing the allocation can neither leave a freed parent pinned nor pair a NULL parent with a request to lock it (found by Sashiko AI review)
- keep -EPROBE_DEFER out of the re-probe error path, where dev_err_probe() would record the message as the device's deferred probe reason (found by Sashiko AI review)
- kernel-doc: a stale re-probe leaves an unbound device unbound, which an unbind followed by a rebind within the delay does not (found by Sashiko AI review)
v14: no changes
v13:
- queue the work on system_freezable_wq, so a re-probe pending across system suspend can neither detach a device the PM core has suspended nor race its late suspend callbacks; it runs after resume instead (found by Sashiko AI review)
- record at scheduling time whether the parent needs locking, instead of reading dev->bus in the work, which may be gone with its module once the device has been unregistered (found by Sashiko AI review)
- let __device_release_driver() report whether it released the driver, so an administrative unbind that wins the race inside the device links loop is not undone by the re-attach (found by Sashiko AI review)
- use dev_err_probe() for the re-probe error path, so a re-probe deferred at resume no longer logs a spurious error (Hans de Goede, on the standalone posting of this helper)
- describe the parent pinning and locking in the commit message, as in the standalone posting
v12:
- pin the parent device across the deferred work; a reference on the child alone left device_reprobe_work_fn() dereferencing a freed dev->parent under __device_driver_lock() when the device was unregistered before the work ran (found by Sashiko AI review)
- take the parent lock across device_attach() on buses that require it, matching bus_rescan_devices_helper() (found by Sashiko AI review)
v11: new patch: add device_schedule_reprobe() to the driver core (posted
earlier as an RFC) so mxl862xx can schedule its post-flash and post-drain re-probe through the core instead of open-coding a work item
drivers/base/dd.c | 126 ++++++++++++++++++++++++++++++++++++++++- include/linux/device.h | 2 + 2 files changed, 126 insertions(+), 2 deletions(-)
drivers/base/dd.c +124 -2
@@ -1315,7 +1315,7 @@ EXPORT_SYMBOL_GPL(driver_attach);* __device_release_driver() must be called with @dev lock held. * When called for a USB interface, @dev->parent lock must be held as well. */ -static void __device_release_driver (struct device *dev,struct device *parent) +static bool __device_release_driver (struct device *dev,struct device *parent) {struct device_driver *drv;
@@ -1336,7 +1336,7 @@ static void __device_release_driver(struct device *dev, struct device *parent)*/ if (dev->driver != drv) {pm_runtime_put (dev); -return ; +return false; } }
@@ -1359,7 +1359,10 @@ static void __device_release_driver(struct device *dev, struct device *parent)bus_notify (dev,BUS_NOTIFY_UNBOUND_DRIVER );kobject_uevent (&dev->kobj,KOBJ_UNBIND ); +return true; } + +return false; } void device_release_driver_internal(struct device *dev,
@@ -1436,3 +1439,122 @@ void driver_detach(const struct device_driver *drv)put_device (dev); } } + +struct device_reprobe { +struct delayed_work work; +struct device *dev; +struct device *parent; +const struct device_driver *drv; +bool parent_lock; +}; + +static void device_reprobe_work_fn (struct work_struct *work) +{ + struct device_reprobe *rp = container_of(work, struct device_reprobe, + work.work); +struct device *parent = rp->parent; +struct device *dev = rp->dev; +bool detached = false; +int ret; + +/* +* A device unregistered before the work runs may have outlived the +* module providing its bus type, so dev->bus is not read until the +* device is known to be live. +*/ +if (rp->parent_lock) +device_lock (parent); +device_lock (dev); +/* +* rp->drv is only ever compared, never dereferenced: the driver it +* points to may have been unregistered and freed by now. +* device_shutdown() blocks probing before its walk reaches @dev. +*/ +if (!defer_all_probes && !dev->p->dead && dev->driver == rp->drv) + detached =__device_release_driver (dev, parent); +device_unlock (dev); +if (rp->parent_lock) +device_unlock (parent); + +if (detached) { +/* +* device_attach() must run with the parent locked on buses +* that require it, mirroring bus_rescan_devices_helper(). +*/ +if (rp->parent_lock) +device_lock (parent); + ret =device_attach (dev); +if (ret <0 && ret != -EPROBE_DEFER ) +dev_err_probe (dev, ret, +"re-probe failed, device left unbound\n" ); +if (rp->parent_lock) +device_unlock (parent); + } + +put_device (dev); +put_device (parent); +kfree (rp); +} + +/** +* device_schedule_reprobe - schedule a deferred detach and re-probe +* @dev: device to detach and re-probe +* @delay_ms: delay in milliseconds before the re-probe runs +* +* Schedule a detach and re-probe of @dev after @delay_ms milliseconds. +* The re-probe is skipped if, by the time the scheduled work runs, the +* device has been removed, probing has been blocked for a system +* shutdown, or @dev is no longer bound to the driver that was bound at +* scheduling time. In particular a device left unbound by an +* administrative unbind stays unbound. +* +* The work function is built-in text, so the bound driver may call this +* from its own code without holding a module reference. If the driver +* module is unloaded before the work runs, driver unregistration unbinds +* @dev first and the scheduled work does nothing. +* +* Multiple pending re-probes for the same device are individually safe; +* a caller that wants at most one pending re-probe must gate scheduling +* itself. +* +* The work is freezable: a re-probe pending across system suspend runs +* once the system has resumed. +* +* May only be called from process context, and not from @dev's own +* ->probe(), which is called with the device lock held. +* +* Returns: 0 on success, -EINVAL if @dev is not a registered device +* bound to a driver, -ENOMEM on allocation failure. +*/ +int device_schedule_reprobe (struct device *dev,unsigned int delay_ms) +{ +struct device_reprobe *rp; +struct device *parent; + + rp =kzalloc_obj (*rp); +if (!rp) +return -ENOMEM ; + +/* device_del() drops @dev's own reference to the parent. */ +device_lock (dev); + parent = dev->parent; +if (!dev->bus || !dev->p || dev->p->dead || + !device_is_registered (dev) || !dev->driver) { +device_unlock (dev); +kfree (rp); +return -EINVAL ; + } + + rp->dev =get_device (dev); + rp->parent =get_device (parent); + rp->parent_lock = parent && dev->bus->need_parent_lock; + rp->drv = dev->driver; +device_unlock (dev); + +INIT_DELAYED_WORK (&rp->work, device_reprobe_work_fn); +queue_delayed_work (system_freezable_wq, &rp->work, +msecs_to_jiffies (delay_ms)); + +return 0 ; +} +EXPORT_SYMBOL_GPL (device_schedule_reprobe);
include/linux/device.h +2 -0
@@ -1314,6 +1314,8 @@ int __must_check device_attach(struct device *dev);int __must_check driver_attach (const struct device_driver *drv);void device_initial_probe (struct device *dev);int __must_check device_reprobe (struct device *dev); +int __must_check device_schedule_reprobe (struct device *dev, +unsigned int delay_ms);bool device_is_bound (struct device *dev);
Signature · 1 line
2.55.0
Daniel Golle
maintainerPATCH v15 4/6 net: dsa: mxl862xx: add devlink flash_update and info_get
In reply to Daniel GolleImplement runtime firmware upgrade via "devlink dev flash" and version reporting via "devlink dev info":
$ devlink dev info mdio_bus/mdio-bus:10
mdio_bus/mdio-bus:10:
driver mxl862xx
versions:
fixed:
asic.id 8628
asic.rev 0
running:
fw 1.0.70
stored:
fw 1.0.70The "asic.id" and "asic.rev" fixed versions carry the numeric chip part number and revision from the static CHIP ID registers (SYS_MISC_REG_RD), which userspace such as fwupd matches firmware against; they are omitted if the read fails or the part is unfused, so no bogus "0000" is published. The switch boots its firmware from its own flash, so "fw" is reported as both the running and the stored version; a flashless part would omit "stored", distinguishing the two without an API change.
$ devlink dev flash mdio_bus/mdio-bus:10 file mxl862xx-fw.bin
The image, including both payload CRCs, is validated first, so a malformed file is rejected without disturbing the running switch. The driver then sends SYS_MISC_FW_UPDATE, which reboots the switch into its MCUboot bootloader, and transfers the signed image over the SB PDI protocol (clause-22 SMDIO), checking every write: a failed address write at the half-bank boundary would otherwise misplace half the payload unnoticed. A successful transfer reboots the switch into the new firmware. The loader verifies the image once the last slice has been programmed and publishes the verdict, so a rejected image is reported as such rather than as a transfer timeout. The whole cycle takes just under a minute.
For its duration the driver closes all user and conduit interfaces and marks the user ports not-present with netif_device_detach() so userspace cannot reopen them; the conduit belongs to the MAC driver and is only closed. This also stops phylib polling the switch-internal PHYs, unreachable in MCUboot. The bridge's deferred STP DISABLED transitions are flushed under rtnl so they reach the firmware while it still runs; the stats poll and CRC error handler are stopped; and firmware API commands from other paths are blocked under the MDIO bus lock so none reaches the bus once the switch has rebooted. Progress is reported through devlink status notifications.
The switch leaves MCUboot on its own by booting the new image, but the driver has no in-place path back, so it reinitialises with a deferred re-probe scheduled regardless of the transfer outcome, using device_schedule_reprobe() from the previous patch. The helper's work runs in the driver core, off the devlink caller's locking and signal context, without this driver holding module or device references, and it skips the re-probe if the device is unbound or shut down before it fires, so a stale re-probe can neither undo an administrative unbind nor detach a device whose ->shutdown() has already run. During the teardown the driver's API reads return -ENODEV and writes fake success, so it neither stalls on the absent firmware nor consumes buffers it never filled; port_mdb_del() takes that -ENODEV for a MAC table that is gone and reports success, since there is nothing left to delete. A failed re-probe leaves the device unbound, exactly as a failed initial probe would, and a further flash is refused until it has run. An aborted transfer leaves the switch in MCUboot, where nothing here can reach it; the next patch adds the detection that makes such a switch flashable again.
Scheduling the re-probe can only fail on memory allocation, and only after the switch has already been flashed. -ENOMEM there is a system-wide condition that no driver-level message or recovery attempt improves, so it is returned as-is with no further action: the driver stays bound with its firmware API short-circuited, and unbinding and rebinding it runs the same teardown and fresh probe the re-probe would have.
The closed user ports and conduit are not returned to their pre-flash administrative state across the reprobe; userspace brings them back up, and restoring it in-driver would need DSA-core support that does not yet exist.
---
v15:
- treat the closing END write as advisory: the loader has left the receive loop and verified the image by then, so a failed write no longer reports a completed flash as a transfer failure (found by Sashiko AI review)
- admit only the flash task's own firmware reads past block_host, instead of every read from any context, which let ethtool and FDB queries reach the freshly booted firmware and left an mdb_add() half executed (found by Sashiko AI review)
v14: no changes, picked up Andrew's v13 Reviewed-by
v13: stop the stats poll with disable_delayed_work_sync() in the flash
path, so a racing get_stats64() re-arm is a no-op, and drop the early return in the work function with it; the v12 reordering of remove() is gone as well, since the race it addressed predates this series and needs a fix of its own (found by Sashiko AI review)
v12:
- cancel the stats poll after dsa_unregister_switch() in .remove(): a get_stats64() past its lockless WORK_STOPPED check could re-arm the work after the cancel and then run against the devres-freed priv (found by Sashiko AI review)
- keep block_host set across the post-flash readiness poll and let only the flash path's own firmware reads through, so a concurrent bridge or STP write cannot reach the freshly booted firmware with stale pre-flash resource IDs while rtnl is dropped (found by Sashiko AI review)
v11:
- schedule the post-flash re-probe with device_schedule_reprobe() instead of a driver-owned work item; the module and device references and the drvdata bound-check go away with it, and with them both findings of the v10 AI review -- the work function no longer ends in module text behind a module_put(), and the bound-check and detach now run under one __device_driver_lock() hold in the core where ->shutdown() cannot interleave between them
- the dsa_switch allocation returns to devres; keeping it out only defused the check-vs-detach window that the core helper now closes outright
- scheduling the re-probe is now the one step that can fail after the switch was flashed, since the helper allocates its own work item; an -ENOMEM there is returned as-is, since unbind and rebind reinitialises the driver
v10:
- do not reprobe a device that has been shut down or unbound. The work cannot be cancelled from teardown: .shutdown() runs under device_lock(), which device_reprobe() takes as well, so a lock shared between the two would deadlock, and cancel_delayed_work_sync() would hang on the nested remove() the work triggers itself. It checks drvdata under device_lock() instead, which both .shutdown() and the driver core clear (found by Sashiko AI review of patch 4, but this is where the reprobe comes from)
- allocate the dsa_switch outside devres and free it in .remove(), so losing the remaining race with .shutdown() cannot let devres free it while the DSA tree still holds dsa_ports pointing at it
- lower the per-slice write timeout from 120 s to 60 s, so this path and the drain added in patch 4 agree on how long the same loader step may take (found by Sashiko AI review)
v9: no changes
v8:
- refuse a second devlink dev flash while the previous one's reprobe is still pending: the firmware API is short-circuited by then, so the FW_UPDATE command faked success and the raw SB PDI writes ran against a switch the driver no longer tracks (found by Sashiko AI review)
- omit the firmware version from devlink dev info while the cached copy is all-zero, so a failed transfer no longer publishes 0.0.0 as both running and stored, and clear asic_rev along with asic_id (found by Sashiko AI review)
- only translate -ENODEV into success in port_mdb_del() during the post-flash teardown; outside it, a genuine bus error was reported to switchdev as a successful deletion (found by Sashiko AI review)
- evaluate the image verification verdict the loader publishes after the last slice, instead of polling for a value it had already published, so a rejected image is no longer reported as a write timeout
- rename the end_magic label to no_end, which is what it does, and correct the protocol comment: END is optional as the loader finalises on a 2 s timeout, the status register keeps the byte count while a chunk is programmed, and the half-bank switch does not clear DATA (found by Sashiko AI review)
v7:
- reprobe from a single delayed work item instead of a kthread spawned by a workqueue kickoff; the kthread existed only to drop the module reference from core code, but its creation-failure path did the racy module_put() from module text anyway and could strand the driver bound with skip_teardown set. The collapsed form matches iwl_trans_reprobe_wk(), and a failed reprobe now leaves the device unbound like a failed probe
- only signal END on a successful transfer; a failure leaves the loader mid-payload, where a STAT write is a byte count and END (0x3cc3) is read as one, risking a receive-counter underflow, so return the error and let the reprobe recover
- add cond_resched() to the payload loop so a long transfer over a bit-banged MDIO bus under CONFIG_PREEMPT_NONE does not trip the soft-lockup detector
- drop the cached firmware version and chip id on a failed flash so devlink dev info stops reporting the pre-flash version until the reprobe re-reads it
- report the firmware version under DEVLINK_INFO_VERSION_GENERIC_FW instead of a bare "fw" string
- correct the SB PDI header comment's SMDIO register map (page in MII reg 0x1f, register from the low nibble) and expand the note on why closing the shared conduit is safe
v6:
- confirm the new firmware is running with mxl862xx_wait_ready() and lift the host block before reporting success, so devlink dev flash completes only once the update has taken effect instead of relying on the later reprobe to pick up the new version
- run the post-flash reprobe from a kthread that drops the module reference with module_put_and_kthread_exit(), spawned from a workqueue kickoff, closing a use-after-free where a work item's trailing module_put() could return into module text a racing rmmod had already freed
- jump to the end_magic teardown on every flash failure from the ready handshake onward, so an aborted transfer sends END and lets MCUboot reboot instead of leaving the loader waiting
- poll the SB PDI status register with read_poll_timeout(), which evaluates the condition once more after the deadline, so a preempted poll cannot report a spurious -ETIMEDOUT
- bail out of the periodic stats poll when the flash teardown has set WORK_STOPPED, closing a get_stats64() re-arm race
- allocate the reprobe kickoff before disturbing the switch, so an -ENOMEM cannot leave it flashed but never reprobed with block_host and skip_teardown stuck set
- omit asic.id/asic.rev when the CHIP ID read returned 0, instead of publishing a bogus "0000" for fwupd to match firmware against
v5:
- report the numeric chip part number and version read from the static CHIP ID registers as "asic.id" and "asic.rev" instead of a model-name string, which does not belong in a devlink version identifier (Jakub Kicinski)
- report the running firmware version as the "stored" version too, since the switch boots it from its own flash, so userspace can tell a flash-backed part from a flashless one by the presence of "stored" without a future API change
- run the post-flash reprobe from a self-contained work item again instead of the v4 kernel thread, which tripped the hung-task watchdog while parked across the flash and returned -EINTR from kthread_create() when the devlink command was interrupted
- re-read the new firmware version through the reprobe's fresh probe and drop the SYS_MISC_FW_VERSION exemption from the host block
- raise the firmware command poll timeout so the FW_UPDATE command that reboots into MCUboot is not cut short
- move the devlink documentation into its own patch
v4:
- run the deferred reprobe from a kernel thread ending in module_put_and_kthread_exit() instead of a work item whose final module_put() raced against module unload
- fail API read commands with -ENODEV after the update instead of faking success with an unfilled buffer, which sent port_fdb_dump() into an endless loop
- keep block_host set across the post-update version query by exempting SYS_MISC_FW_VERSION instead of briefly lifting the block, and write the blocking flags under the MDIO bus lock
- check the return value of every SB PDI control write; a failed address write during the half-bank switch could place the second half of the payload at the wrong flash offset undetected
- report SMDIO write failures through one shared error path instead of per-site messages
- initialise the progress notification deadline from jiffies so notifications are not suppressed on 32-bit shortly after boot
- flush the switchdev deferred queue after closing the ports so the bridge's deferred STP DISABLED transitions reach the firmware while it is still running instead of failing with -EBUSY against the host block
- treat -ENODEV as successful deletion in port_mdb_del() so the post-update teardown does not leave leftover host MDB entries behind for the DSA core to report
v3:
- validate the image, including both CRCs, before closing any ports so a malformed file no longer triggers a flash and reprobe cycle
- reject images whose declared payload sizes overflow when summed (check_add_overflow) or sum up to zero; the latter used to erase the flash without writing anything back
- allocate the reprobe work item and take the module and device references before disturbing the switch instead of silently skipping the reprobe when the allocation fails afterwards
- check block_host/skip_teardown under the MDIO bus lock to close the window where a command already past the check could reach the bus after the switch rebooted into MCUboot
- prevent the stats poll work from being re-armed and cancel the CRC error work before the transfer
- check the return value of SB PDI data word writes; control writes are verified by the subsequent status polls
- report a per-model chip name from the OF match data as "asic.id" instead of the devicetree compatible string whose comma is awkward for userspace consumers (Andrew Lunn)
- commit message: the conduit is only closed, not detached
v2:
- factor out SB PDI slice flush and devlink status notification helpers, resolving checkpatch issues
- use kzalloc_obj() (Manuel Ebner)
- add kernel-doc for the new mxl862xx_priv members
- trim comments and state the actual duration of a flash and reprobe cycle, just under a minute (Manuel Ebner)
- reword commit message: split up run-on sentence, explain the dynamically allocated reprobe work item (Manuel Ebner), mention that closing the ports stops phylib polling (Andrew Lunn)
drivers/net/dsa/mxl862xx/Makefile | 2 +- drivers/net/dsa/mxl862xx/mxl862xx-api.h | 10 + drivers/net/dsa/mxl862xx/mxl862xx-cmd.h | 2 + drivers/net/dsa/mxl862xx/mxl862xx-fw.c | 648 +++++++++++++++++++++++ drivers/net/dsa/mxl862xx/mxl862xx-fw.h | 17 + drivers/net/dsa/mxl862xx/mxl862xx-host.c | 17 + drivers/net/dsa/mxl862xx/mxl862xx.c | 62 ++- drivers/net/dsa/mxl862xx/mxl862xx.h | 17 + 8 files changed, 773 insertions(+), 2 deletions(-) create mode 100644 drivers/net/dsa/mxl862xx/mxl862xx-fw.c create mode 100644 drivers/net/dsa/mxl862xx/mxl862xx-fw.h
drivers/net/dsa/mxl862xx/Makefile +1 -1
@@ -1,3 +1,3 @@ # SPDX-License-Identifier: GPL-2.0 obj-$(CONFIG_NET_DSA_MXL862) += mxl862xx_dsa.o -mxl862xx_dsa-y := mxl862xx.o mxl862xx-host.o mxl862xx-phylink.o +mxl862xx_dsa-y := mxl862xx.o mxl862xx-host.o mxl862xx-phylink.o mxl862xx-fw.o
drivers/net/dsa/mxl862xx/mxl862xx-api.h +10 -0
@@ -1224,6 +1224,16 @@ struct mxl862xx_sys_fw_image_version {__le32 iv_build_num; } __packed; +/** +* struct mxl862xx_sys_reg_rw - System register read/write +* @addr: 32-bit register address +* @val: register value +*/ +struct mxl862xx_sys_reg_rw { +__le32 addr; +__le32 val; +} __packed; +/** * enum mxl862xx_port_type - Port Type * @MXL862XX_LOGICAL_PORT: Logical Port
drivers/net/dsa/mxl862xx/mxl862xx-cmd.h +2 -0
@@ -70,7 +70,9 @@#define INT_GPHY_READ (GPY_GPY2XX_MAGIC + 0x1)#define INT_GPHY_WRITE (GPY_GPY2XX_MAGIC + 0x2) +#define SYS_MISC_FW_UPDATE (SYS_MISC_MAGIC + 0x1)#define SYS_MISC_FW_VERSION (SYS_MISC_MAGIC + 0x2) +#define SYS_MISC_REG_RD (SYS_MISC_MAGIC + 0x8)#define MXL862XX_XPCS_PCS_CONFIG (MXL862XX_XPCS_MAGIC + 0x1)#define MXL862XX_XPCS_PCS_GET_STATE (MXL862XX_XPCS_MAGIC + 0x2)
drivers/net/dsa/mxl862xx/mxl862xx-fw.c new file +648 -0
648 lines not on this page · raw message
drivers/net/dsa/mxl862xx/mxl862xx-fw.h new file +17 -0
@@ -0,0 +1,17 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#ifndef __MXL862XX_FW_H +#define __MXL862XX_FW_H + +#include <net/dsa.h> + +struct mxl862xx_priv ; + +int mxl862xx_devlink_info_get (struct dsa_switch *ds, +struct devlink_info_req *req, +struct netlink_ext_ack *extack); +int mxl862xx_devlink_flash_update (struct dsa_switch *ds, +struct devlink_flash_update_params *params, +struct netlink_ext_ack *extack); + +#endif /* __MXL862XX_FW_H */
drivers/net/dsa/mxl862xx/mxl862xx-host.c +17 -0
@@ -12,9 +12,11 @@#include <linux/crc16.h> #include <linux/iopoll.h> #include <linux/limits.h> +#include <linux/sched.h> #include <linux/unaligned.h> #include <net/dsa.h> #include "mxl862xx.h" +#include "mxl862xx-cmd.h" #include "mxl862xx-host.h" #define CTRL_BUSY_MASK BIT(15)
@@ -340,6 +342,21 @@ int mxl862xx_api_wrap(struct mxl862xx_priv *priv, u16 cmd, void *_data,mutex_lock_nested (&priv->mdiodev->bus->mdio_lock,MDIO_MUTEX_NESTED ); +if (priv->skip_teardown) { + ret = read ? -ENODEV :0 ; + goto out; + } + +/* During the post-flash readiness poll block_host stays set, but the +* flash path's own firmware version reads must reach the new image; +* host writes stay blocked so stale resource IDs cannot corrupt it. +*/ +if (priv->block_host && cmd !=SYS_MISC_FW_UPDATE && + !(read && priv->flash_owner == current)) { + ret = -EBUSY ; + goto out; + } + max = (size +1 ) /2 ; ret =mxl862xx_busy_wait (priv);
drivers/net/dsa/mxl862xx/mxl862xx.c +61 -1
98 lines not on this page · raw message
drivers/net/dsa/mxl862xx/mxl862xx.h +17 -0
@@ -303,6 +303,10 @@ struct mxl862xx_fw_version {* flooding) * @fw_version: cached firmware version, populated at probe and * compared with MXL862XX_FW_VER_MIN() +* @asic_id: chip part number read from the CHIP ID registers, +* reported as the devlink "asic.id" fixed version +* @asic_rev: chip version read from the CHIP ID registers, +* reported as the devlink "asic.rev" fixed version * @serdes_ports: SerDes interfaces incl. sub-interfaces in case of * 10G_QXGMII or QSGMII * @serdes_refcount: per-XPCS count of sub-ports enabled by phylink;
@@ -319,6 +323,12 @@ struct mxl862xx_fw_version {* @evlan_ingress_size: per-port ingress Extended VLAN block size * @evlan_egress_size: per-port egress Extended VLAN block size * @vf_block_size: per-port VLAN Filter block size +* @block_host: reject firmware API commands (except FW_UPDATE) +* during a firmware flash +* @flash_owner: task running the post-flash readiness poll; only its +* own firmware reads pass block_host +* @skip_teardown: discard firmware API commands during the teardown +* triggered by the post-flash reprobe * @stats_work: periodic work item that polls RMON hardware counters * and accumulates them into 64-bit per-port stats */
@@ -329,6 +339,8 @@ struct mxl862xx_priv {unsigned long flags;u16 drop_meter;struct mxl862xx_fw_version fw_version; +u16 asic_id; +u8 asic_rev;struct mxl862xx_pcs serdes_ports[8 ];int serdes_refcount[2 ];struct mutex serdes_lock;
@@ -337,7 +349,12 @@ struct mxl862xx_priv {u16 evlan_ingress_size;u16 evlan_egress_size;u16 vf_block_size; +struct task_struct *flash_owner; +bool block_host; +bool skip_teardown; struct delayed_work stats_work; }; +int mxl862xx_wait_ready (struct dsa_switch *ds); +#endif /* __MXL862XX_H */
Signature · 1 line
2.55.0
Daniel Golle
maintainerPATCH v15 5/6 net: dsa: mxl862xx: recover switch stuck in MCUboot rescue mode
In reply to Daniel GolleA broken or interrupted firmware image, or the sticky rescue bit, keeps the switch in its MCUboot bootloader, which exposes only the clause-22 SMDIO download interface. The clause-45 MMD API never comes up, so probe would fail with -ETIMEDOUT and the only way back would be the switch's UART console, or a power cycle or out-of-band reset (not currently implemented).
Probe for the loader over SB PDI at setup, before any clause-45 access, since the C45 API floods the log with CRC errors when no firmware answers. A scratch write to two mailbox registers first establishes that a switch is there at all. It reaches a running firmware as well, but lands in registers that firmware does not read, so it is inert there. The status register the loader publishes then tells the cases apart without touching C45: a running firmware, which answers with its own non-zero status word (0x0003 on the firmware tested), so probe continues normally; a loader idle in its console loop, confirmed live by a register-read challenge; a loader wedged mid-download, the one case that publishes zero; the flashless download loop, which this driver cannot drive; and a switch whose scratch write does not latch -- absent, unpowered, misdescribed in the device tree (wrong address or bus, or a reset GPIO with inverted polarity), or with its SB PDI window somewhere other than the OTP reset offsets assumed here. The first three enter rescue mode or normal operation, the last two fail probe cleanly with -EOPNOTSUPP and -ENODEV instead of a CRC-error storm.
A loader that publishes the ready magic but never services the register-read challenge fails probe too, with -ENXIO. The challenge is what tells the loader apart from a firmware whose status word happens to read the same value, and offering to flash a healthy firmware would be worse than refusing to bind, so a mailbox that does not answer is treated as unusable rather than as a flash target. Every loader tested services it.
In rescue mode the switch registers without user interfaces so devlink stays available: user ports fail port_setup with -ENODEV (the DSA core re-registers them as unused) while shared and CPU ports succeed, and the CPU port works on its fixed link with mac_select_pcs returning no PCS. Firmware API commands fail fast with -ENODEV and the port and STP callbacks become no-ops.
An interrupted download can leave the loader wedged mid-payload. A background work item off the devlink flash path drains it back to a clean ready state by feeding the outstanding byte count one byte at a time, which takes tens of minutes for a large image and is logged as it progresses; until then devlink dev info reports no version and devlink dev flash returns -EBUSY, and -EIO once a drain has failed for good. Reaching the end of the count is all the drain does: the loader then verifies the corrupt image and returns to its console loop on its own, so the drain reprobes and lets the probe-time detection re-classify the switch -- a valid image that a last-moment interruption left bootable comes up as running firmware, with no second-guessing in the drain path.
The re-probe the drain schedules is the same device_schedule_reprobe() hand-off the flash path uses: the core skips it if the device is unbound or shut down before it fires, so a drain finishing after the driver is gone does nothing. Should scheduling it fail, recovery is marked failed, since the loader would otherwise sit at a clean ready state that nothing reclassifies while devlink keeps promising that a retry will work.
The CHIP ID registers need a running firmware, so no asic.id/asic.rev is reported in rescue mode. Once the loader is ready, devlink dev info reports the null firmware version "0.0.0" as both running and stored:
$ devlink dev info mdio_bus/mdio-bus:10
mdio_bus/mdio-bus:10:
driver mxl862xx
versions:
running:
fw 0.0.0
stored:
fw 0.0.0An operational switch never reports 0.0.0 (a released firmware's major is non-zero), so version-comparing tools like fwupd offer every release as an upgrade, recovering the switch through the regular flash flow, matched on the driver name. The flash skips the FW_UPDATE command since MCUboot is already waiting. A successful flash reboots the switch into the new firmware and the reprobe then brings the driver up against it normally; after a failed one the switch is still in MCUboot, rescue mode is detected again, and the user can retry.
---
v15:
- classify a status register left in the download handshake as a loader needing a power cycle, rather than as a running firmware, which made probe fail with the CRC-error storm this patch avoids (found by Sashiko AI review)
- give the loader one step to publish its next state when detection runs after a failed clause-45 wait, so the count of a chunk it is still programming is not read as a firmware status word (found by Sashiko AI review)
- abort the drain polls as soon as teardown asks for it, instead of holding up unbind and shutdown for up to 17 s (found by Sashiko AI review)
- pair the rescue_mode accesses with WRITE_ONCE()/READ_ONCE(), like the sibling rescue flags (found by Sashiko AI review)
v14:
- initialise the SerDes state once mxl862xx_wait_ready() has cached the firmware version, still before the rescue-mode early return, so PCS setup can depend on the running firmware
v13: no changes
v12: no changes
v11:
- schedule the post-drain re-probe with device_schedule_reprobe() too, instead of a driver-owned work item
- a drain whose re-probe hand-off fails still marks recovery failed, so devlink does not keep promising a retry
v10:
- share the SB PDI timeouts with the flash path: one constant for the verify wait (15 s) and one for a single 1-byte mailbox step (2 s), the latter also replacing the separate detection timeout. The last-slice flush gets the sum of the write and verify budgets, since it cannot see the boundary between programming and verifying (found by Sashiko AI review)
- report a reprobe hand-off that cannot be set up after a successful drain, instead of leaving devlink answering "retry shortly" for good for a loader sitting at a clean READY (found by Sashiko AI review)
- drop heal_lock and mxl862xx_stop_work() with it: making the flag test and the queueing atomic was never the guarantee its comment claimed, and the reprobe now decides for itself whether it may still run (found by Sashiko AI review)
- return -ENXIO rather than a propagated -ETIMEDOUT when the loader never re-arms READY for the register-read challenge, and correct the documented return sets of mxl862xx_rescue_mode_detect() and mxl862xx_rescue_drain_finish() (found by Sashiko AI review)
- explain why STAT == 0 during a drain is unambiguous: by the r_remain == 0 rule the loader cannot be both inside the receive loop asking for a chunk and publishing a verdict (found by Sashiko AI review)
- commit message: a running firmware is not "left untouched", the presence probe writes two mailbox scratch registers which are inert to it; an SB PDI window away from the OTP reset offsets also yields -ENODEV; and describe the -ENXIO outcome for a READY loader that never services the challenge (found by Sashiko AI review)
v9: no changes
v8:
- never send END from the drain: the loader keeps the host's byte count in its status register while it programs a chunk, so a lingering count cannot be told from the "image rejected" verdict, and END written into the receive loop is consumed as a 15555-byte count and underflows the receive counter. Wait for the loader to ask for the next chunk or to return to its console loop instead, since it finalises on its own (found by Sashiko AI review)
- initialise the SerDes state before the rescue-mode early return, so the window between a successful rescue-mode flash clearing rescue_mode and the reprobe cannot hand phylink a PCS with no ops and an uninitialised mutex (found by Sashiko AI review)
- do not fail probe when the 1-byte slice-advance leaves the wedged loader somewhere other than asking for the next chunk: a download interrupted with exactly one byte outstanding completes on that byte, after which the loader verifies and returns to its console loop (found by Sashiko AI review)
- report a failed drain and refuse further flashes with -EIO and an extack asking for a power cycle, instead of leaving devlink to answer "retry shortly" forever for a switch that never becomes ready (found by Sashiko AI review)
- reset the mailbox before the presence probe: a download interrupted with the write latch armed made the scratch write land in switch memory instead, so detection returned -ENODEV for the very state it exists to recover (found by Sashiko AI review)
- tell an SMDIO bus error apart from a loader failing the register-read challenge, and check the reset issued after it (found by Sashiko AI review)
- reject DSA links before the rescue-mode shortcut, so an unsupported cascade topology fails probe in rescue mode too (found by Sashiko AI review)
- serialise the self-heal's reprobe hand-off against teardown with a mutex (found by Sashiko AI review)
- log the drain's progress, name its timeouts, and describe its real duration (found by Sashiko AI review)
- WRITE_ONCE() the rescue_ready stores, document what orders rescue_mode, and correct the detection kernel-doc and the note on the OTP-configurable SB PDI register offsets (found by Sashiko AI review)
v7:
- queue the reprobe as a delayed work item from the background self-heal, following the previous patch's move off the reprobe kthread
- report the rescue-mode firmware version under DEVLINK_INFO_VERSION_GENERIC_FW too
- drop two redundant rescue-recovery log lines; the setup message ("switch in MCUboot with an interrupted download, recovering in background") already says it
- return distinct errno from rescue_mode_detect() so an absent switch (-ENODEV), one strapped into flashless-download mode (-EOPNOTSUPP) and one that answers SB PDI READY but fails the register-read challenge, or wedges without draining (-ENXIO), are no longer all reported as -ENODEV
v6:
- after the background drain finalises the interrupted transfer, reprobe and let the probe-time detection re-classify the switch, so a valid image a last-moment interruption left bootable is picked up as running firmware; rescue_drain() no longer inspects or reports the outcome (its stale kernel-doc claiming a "return 1" case is gone)
- poll the drain status register with read_poll_timeout() as well, which evaluates the condition once more after the deadline, matching the poll fix in the previous patch
- treat the flashless-download loop (STAT 0xc33c) as an unsupported configuration and fail probe with -ENODEV, rather than advertising it as flashable when the console flash path cannot drive it
v5:
- detect the switch state from the value MCUboot publishes in the SB PDI STAT register (loader ready, wedged download, or running firmware), confirming a live console loader with a register-read challenge, instead of trusting a bare SMDIO scratch write
- fail probe with -ENODEV over SB PDI when the switch does not respond at all -- absent, unpowered, or misdescribed in the device tree -- instead of letting the clause-45 API flood the log with CRC errors
- drain a wedged interrupted download back to a clean ready state from a background work item so the multi-minute recovery never holds the devlink instance lock, and refuse devlink dev info and flash until it is ready
- report the null firmware version as the stored version too, matching the running/stored reporting of the previous patch
- do not report asic.id/asic.rev in rescue mode as the CHIP ID registers are unreadable without firmware; recovery tools match on the driver name and the "0.0.0" version instead (follows the numeric asic.id change in the previous patch)
- move the devlink documentation into its own patch
v4:
- log a distinct diagnostic when rescue mode detection fails on an SMDIO bus error instead of silently treating it as "not in rescue mode"
- clear the rescue_mode flag under the MDIO bus lock, following the flag write locking in the previous patch
v3:
- report the canonical null version "0.0.0" instead of "mcuboot-rescue" so that version-comparing update tools like fwupd offer any available release as an upgrade for recovery
- check the rescue_mode flag under the MDIO bus lock, following the block_host/skip_teardown change in the previous patch
v2: new patch, allowing recovery from a failed or interrupted update
without having to use a special recovery OS image (Andrew Lunn)
drivers/net/dsa/mxl862xx/mxl862xx-fw.c | 477 +++++++++++++++++++- drivers/net/dsa/mxl862xx/mxl862xx-fw.h | 3 + drivers/net/dsa/mxl862xx/mxl862xx-host.c | 8 + drivers/net/dsa/mxl862xx/mxl862xx-phylink.c | 2 + drivers/net/dsa/mxl862xx/mxl862xx.c | 99 +++- drivers/net/dsa/mxl862xx/mxl862xx.h | 20 + 6 files changed, 581 insertions(+), 28 deletions(-)
drivers/net/dsa/mxl862xx/mxl862xx-fw.c +465 -12
@@ -29,9 +29,11 @@* * STAT magics: * READY 0xc55c loader idle in the console loop (this driver) +* DL_RDY 0xc33c loader idle in the flashless loop * START 0xf48f host -> begin download session * ACK 0xf490 loader -> START acknowledged (START + 1) * END 0x3cc3 host -> finalise now (optional, see below) +* RDREG 0xe2c0 host -> register-read command (| index), see below * * Console flash path (STAT=0xc55c) - mxl862xx_flash_firmware(): *
@@ -71,7 +73,40 @@* - never send a slice/chunk count larger than what is outstanding; * - a STAT write is a command only once the loader has left the loop; * - the loader leaves the count in STAT while it programs the chunk, so -* a lingering count does not distinguish "busy" from "verdict". +* a lingering count does not distinguish "busy" from "verdict"; +* - interrupted-download recovery feeds 1 byte at a time (see below). +* +* Interrupted-flash recovery (mxl862xx_rescue_drain): +* A host that dies mid-payload leaves the loader in the receive loop holding +* STAT=0. Feed single 1-byte chunks (one DATA word + STAT=1) until r_remain +* reaches 0; the loader then verifies the (now corrupt) image, publishes its +* verdict and comes back to READY by itself. END is never sent here: while +* r_remain is non-zero it would be consumed as a 15555-byte count, and a +* lingering STAT=1 cannot be told from a chunk still being programmed. +* +* Register-read challenge (non-destructive liveness proof): +* DATA := 0x7c23 (marker); STAT := 0xe2c0|idx +* -> loader returns a runtime word in DATA and re-arms STAT=0xc55c. +* The reply source is loader BSS, not a chip id; used only to prove a live +* mailbox in mxl862xx_rescue_mode_detect(). +* +* The other STAT ready magic, 0xc33c, marks the loader's flashless +* chip-to-chip download mode (MxL86281S 16-port tier); this driver does not +* use it. +* +* Rescue lifecycle (devlink): probe runs mxl862xx_rescue_mode_detect(); a +* wedged loader is drained back to READY by a background self-heal +* (rescue_heal_work), so the long recovery never holds the devlink lock. +* devlink dev info exposes the fw version (the "flashable" signal) only once at +* READY; flash_update returns -EBUSY until then, and reprobes to WSP firmware +* on success. +* +* Notes: +* - Chip id/revision (0xc0d28884/88) are NOT reachable on this channel; they +* need the clause-45 MMD firmware mailbox, which is dead under MCUboot. +* Rescue identity is by SB PDI behaviour only (mxl862xx_rescue_mode_detect). +* - The SMDIO PHY address comes from the device tree; the 0xe1xx register +* offsets are the OTP reset defaults and the only layout supported here. */ #include <linux/crc32.h>
@@ -104,8 +139,15 @@/* SB PDI handshake magic (published/consumed via STAT) */ #define MXL862XX_SB_PDI_READY 0xc55c/* loader idle, console loop */ +#define MXL862XX_SB_PDI_DL_READY 0xc33c/* loader idle, flashless loop */ #define MXL862XX_SB_PDI_START 0xf48f#define MXL862XX_SB_PDI_END 0x3cc3 +#define MXL862XX_SB_PDI_RDREG 0xe2c0/* register-read cmd (| index) */ +#define MXL862XX_SB_PDI_RDREG_MARK 0x7c23/* marker placed in DATA for RDREG */ + +/* Behavioural presence probe: two distinct 16-bit latches on ADDR/DATA. */ +#define MXL862XX_SB_PDI_PROBE_A 0x5a5a +#define MXL862XX_SB_PDI_PROBE_D 0xa5a5/* Image verification verdict published in STAT once the receive loop ends */ #define MXL862XX_SB_PDI_VERIFY_OK 0
@@ -124,6 +166,10 @@#define MXL862XX_FW_WRITE_TIMEOUT_MS 60000#define MXL862XX_FW_REBOOT_DELAY_MS 5000#define MXL862XX_FW_REPROBE_DELAY_MS 500 +/* One loader mailbox step: program a 1-byte chunk or service a command */ +#define MXL862XX_SB_PDI_STEP_MS 2000 +/* Covers the loader's END wait, verification and the reset into READY */ +#define MXL862XX_SB_PDI_VERIFY_MS 15000static int mxl862xx_sb_pdi_reset (struct mxl862xx_priv *priv) {
@@ -193,7 +239,8 @@ static int mxl862xx_sb_pdi_flush_last(struct mxl862xx_priv *priv, ret =read_poll_timeout (mxl862xx_smdio_read, val, val <0 || (u16 )val != (u16 )data_written, -10000 ,MXL862XX_FW_WRITE_TIMEOUT_MS *1000 , +10000 , (MXL862XX_FW_WRITE_TIMEOUT_MS + +MXL862XX_SB_PDI_VERIFY_MS ) *1000 , false, priv,MXL862XX_SB_PDI_STAT );if (val <0 )return val;
@@ -219,6 +266,371 @@ static void mxl862xx_flash_notify(struct devlink *dl, const char *status,devlink_flash_update_status_notify (dl, status,NULL , done, total); } +/* Byte-count of each chunk fed to the loader during drain. It MUST be 1: the +* loader only lets us observe "counter == 0", never "counter < step", so any +* step > 1 can subtract past zero, underflow the 32-bit counter and wedge the +* loader for ~2^32 more bytes (a state only a power cycle clears). Stepping by +* 1 walks the counter through every value and is guaranteed to land on zero +* whatever its (possibly odd) start. A 1-byte chunk is a path the loader +* already handles: the normal transfer ends with a single trailing byte for +* odd-sized images (see Step 6). +*/ +#define MXL862XX_DRAIN_CHUNK_BYTES 1 + +/* Log the drain's progress every so many bytes; it can run for a long time */ +#define MXL862XX_DRAIN_LOG_BYTES (128 * 1024) + +/* Wait for the loader to ask for the next chunk (STAT 0) or to come back to its +* command loop (STAT READY), and return the STAT value either way. On timeout +* that is whatever STAT still holds, which carries no further information: the +* loader keeps the count we wrote visible while it programs the chunk, and that +* is the same value it publishes as the "image rejected" verdict once the +* counter reaches zero. +* +* STAT 0 is unambiguous here even though it is also the "image verified" +* verdict: by the r_remain == 0 rule the loader leaves the receive loop the +* moment the counter reaches zero, so it is never both inside the loop asking +* for a chunk and publishing a verdict. Once it has left, the next STAT write +* is a command rather than a count, so feeding one more chunk after a verdict +* cannot underflow anything either. +*/ +static int mxl862xx_sb_pdi_poll_drain (struct mxl862xx_priv *priv, +unsigned long timeout_ms) +{ +int val; + +read_poll_timeout (mxl862xx_smdio_read, val, + val <0 || (u16 )val ==MXL862XX_SB_PDI_READY || + (u16 )val ==0 || +test_bit (MXL862XX_FLAG_WORK_STOPPED , &priv->flags), +50 , timeout_ms *1000 , false, + priv,MXL862XX_SB_PDI_STAT ); +if (val <0 ) +return val; +if (test_bit (MXL862XX_FLAG_WORK_STOPPED , &priv->flags)) +return -ECANCELED ; +return (u16 )val; +} + +/* The loader is not asking for a chunk: it may still be programming the last +* one, or the counter has reached zero and it is verifying the image and +* resetting into READY. Wait that out -- STAT cannot tell the two apart, and +* guessing would mean writing END into a live receive loop. +* +* Return: 0 once the loader has left the loop, -EAGAIN if it asks for another +* chunk after all, -EIO for a loader still holding the count when the verify +* window expires, or an SMDIO bus error. +*/ +static int mxl862xx_rescue_drain_finish (struct mxl862xx_priv *priv,u32 chunk) +{ +struct device *dev = &priv->mdiodev->dev; +int stat; + + stat =mxl862xx_sb_pdi_poll_drain (priv,MXL862XX_SB_PDI_VERIFY_MS ); +if (stat <0 ) +return stat; +if (stat ==MXL862XX_SB_PDI_READY ) +return 0 ; +if (stat ==MXL862XX_SB_PDI_VERIFY_BAD ) { +dev_err (dev, +"flash: loader stuck after %u chunks, power cycle it\n" , + chunk); +return -EIO ; + } +if (stat) { +/* A firmware is answering, not the loader: an image survived +* in flash and booted. +*/ +dev_info (dev,"flash: firmware booted while draining\n" ); +return 0 ; + } + +return -EAGAIN ; +} + +/* Recover a switch whose SB PDI download was interrupted mid-transfer - the +* host died after MCUboot began erasing flash, whether it aborted mid erase or +* mid image-write, both end up in the same place: the payload receive loop. +* There the loader publishes STAT=0, waits for the host to write a byte-count +* to STAT, DMAs that many bytes and subtracts the count from a remaining-bytes +* counter, leaving the loop only when the counter reaches exactly zero. The +* image size died with the host, so we feed single-byte chunks (see +* MXL862XX_DRAIN_CHUNK_BYTES) to walk the counter to zero without underflow. +* The loader then verifies the (now corrupt) image and returns to READY by +* itself, or boots a valid image that happened to survive in flash; either way +* the caller's reprobe classifies the result. Every byte costs about a dozen +* MDIO frames, so a multi-MiB outstanding count takes tens of minutes. +* Returns 0 once the loader has left the receive loop, <0 on error. Does NOT +* recover a counter already underflowed by an earlier oversized-chunk attempt +* - that needs a power cycle. +*/ +static int mxl862xx_rescue_drain (struct mxl862xx_priv *priv) +{ +struct device *dev = &priv->mdiodev->dev; +/* Bound: twice the loader's 16 MiB image cap, one byte per chunk. */ +u32 max_chunks =2u * (16u <<20 ) /MXL862XX_DRAIN_CHUNK_BYTES ; +u32 chunk =0 ; +int ret, stat; + +while (chunk < max_chunks) { +/* Teardown can interrupt this long drain. */ +if (test_bit (MXL862XX_FLAG_WORK_STOPPED , &priv->flags)) +return -ECANCELED ; + + stat =mxl862xx_sb_pdi_poll_drain (priv,MXL862XX_SB_PDI_STEP_MS ); +if (stat <0 ) +return stat; +if (stat ==MXL862XX_SB_PDI_READY ) +return 0 ; + +if (stat) { + ret =mxl862xx_rescue_drain_finish (priv, chunk); +if (ret != -EAGAIN ) +return ret; + } + +/* Feed one zero byte; reset cleared the write latch. */ + ret =mxl862xx_smdio_write (priv,MXL862XX_SB_PDI_CTRL , +MXL862XX_SB_PDI_CTRL_WR ); +if (ret <0 ) +return ret; + ret =mxl862xx_smdio_write (priv,MXL862XX_SB_PDI_DATA ,0x0000 ); +if (ret <0 ) +return ret; + ret =mxl862xx_sb_pdi_reset (priv); +if (ret <0 ) +return ret; + ret =mxl862xx_smdio_write (priv,MXL862XX_SB_PDI_STAT , +MXL862XX_DRAIN_CHUNK_BYTES ); +if (ret <0 ) +return ret; + chunk++; +if (!(chunk %MXL862XX_DRAIN_LOG_BYTES )) +dev_info (dev,"flash: drained %u KiB so far\n" , + chunk /1024 ); +cond_resched (); + } + +dev_err (dev, +"flash: interrupted download did not drain after %u chunks\n" , + chunk); + +return -ETIMEDOUT ; +} + +/* Background self-heal: drain a wedged download off the devlink flash path, so +* the long recovery never holds the devlink lock. Scheduled from probe; +* reprobes on success so the probe-time detection re-classifies the switch. +*/ +void mxl862xx_rescue_heal_work_fn (struct work_struct *work) +{ +struct mxl862xx_priv *priv = + container_of(work, struct mxl862xx_priv, rescue_heal_work); +struct device *dev = &priv->mdiodev->dev; +int ret; + + ret =mxl862xx_rescue_drain (priv); +if (ret == -ECANCELED ) +return ; +if (ret) { +/* Nothing retries this, so say so: rescue_ready stays clear +* and devlink dev flash reports why it refuses. +*/ +dev_err (dev,"flash: download recovery failed: %pe\n" , +ERR_PTR (ret)); +WRITE_ONCE (priv->rescue_failed, true); +return ; + } + +/* The interrupted transfer is finalised; reprobe so the probe-time +* detection brings the driver up -- flashable in rescue mode if the +* loader is at READY, or normally if a valid image booted. The core +* skips the re-probe on its own if the device is unbound first; the +* flag test only avoids scheduling one certain to be skipped. A +* failed hand-off leaves nothing to reclassify the switch, so mark +* recovery failed rather than promise a retry that cannot succeed. +*/ +if (test_bit (MXL862XX_FLAG_WORK_STOPPED , &priv->flags)) +return ; + +if (device_schedule_reprobe (dev,MXL862XX_FW_REPROBE_DELAY_MS )) +WRITE_ONCE (priv->rescue_failed, true); +} + +/* Detect MCUboot rescue mode over clause-22 SMDIO alone, so the caller can rule +* the loader out before any C45 API request (which spews CRC errors when no WSP +* firmware answers). A scratch write to ADDR/DATA must latch or the chip is +* absent (-ENODEV); the mailbox is reset first, or a transfer interrupted with +* CTRL=WR would take that write as a payload word instead of latching it. STAT +* then classifies the state, poked destructively only when 0, the one value a +* running firmware never holds: +* +* - 0xc33c: flashless loop; recognised but not supported here. +* - 0xc55c: console loop, if the register-read challenge is serviced. +* - 0xf48f/0xf490: a download handshake nobody can finish; rescue, but only +* a power cycle gets the loader out of it. +* - other non-zero: running firmware, left unpoked. With @settle the loader +* gets one step to publish 0 or READY first, for a caller which has ruled +* a running firmware out already. +* - 0: wedged receive loop; the 1-byte slice-advance then says whether it +* still needs draining or has just finished. +* +* The scratch write reaches a running firmware too, but lands in mailbox +* registers it does not read, so it is inert there. +* +* Return: MXL862XX_IN_RESCUE, MXL862XX_NOT_RESCUE, -ENODEV when the scratch +* write does not latch, which is a switch that does not answer at all or one +* whose SB PDI window is not at the offsets above, -EOPNOTSUPP for the +* flashless loop, -ENXIO for a READY loader whose mailbox fails the challenge, +* or an SMDIO bus error. +*/ +int mxl862xx_rescue_mode_detect (struct mxl862xx_priv *priv,bool settle) +{ +int stat, dat, ret, rb, a, d; + +/* rescue_ready gates flashing; a wedged loader needs the drain first. */ +WRITE_ONCE (priv->rescue_ready, false); + + ret =mxl862xx_sb_pdi_reset (priv); +if (ret <0 ) +return ret; + +/* Presence: a live chip latches the scratch write, an absent one floats. */ + a =mxl862xx_smdio_write (priv,MXL862XX_SB_PDI_ADDR , +MXL862XX_SB_PDI_PROBE_A ); +if (a <0 ) +return a; + d =mxl862xx_smdio_write (priv,MXL862XX_SB_PDI_DATA , +MXL862XX_SB_PDI_PROBE_D ); +if (d <0 ) +return d; + a =mxl862xx_smdio_read (priv,MXL862XX_SB_PDI_ADDR ); +if (a <0 ) +return a; + d =mxl862xx_smdio_read (priv,MXL862XX_SB_PDI_DATA ); +if (d <0 ) +return d; +if ((u16 )a !=MXL862XX_SB_PDI_PROBE_A || + (u16 )d !=MXL862XX_SB_PDI_PROBE_D ) +return -ENODEV ; + + ret =mxl862xx_sb_pdi_reset (priv); +if (ret <0 ) +return ret; + + stat =mxl862xx_smdio_read (priv,MXL862XX_SB_PDI_STAT ); +if (stat <0 ) +return stat; + +/* Flashless-download loop (MxL86281S tier): this driver does not +* support it -- the console flash path expects READY. Treat it as an +* unusable configuration, like any other unsupported state. +*/ +if ((u16 )stat ==MXL862XX_SB_PDI_DL_READY ) +return -EOPNOTSUPP ; + +/* Console loop at READY: confirm the live mailbox with the register-read +* challenge (consumes the marker from DATA and re-arms READY). +*/ +if ((u16 )stat ==MXL862XX_SB_PDI_READY ) { + ret =mxl862xx_smdio_write (priv,MXL862XX_SB_PDI_DATA , +MXL862XX_SB_PDI_RDREG_MARK ); +if (ret <0 ) +return ret; + ret =mxl862xx_smdio_write (priv,MXL862XX_SB_PDI_STAT , +MXL862XX_SB_PDI_RDREG ); +if (ret <0 ) +return ret; + rb =mxl862xx_sb_pdi_poll_stat (priv,MXL862XX_SB_PDI_READY , +MXL862XX_SB_PDI_STEP_MS ); + dat =mxl862xx_smdio_read (priv,MXL862XX_SB_PDI_DATA ); + ret =mxl862xx_sb_pdi_reset (priv); +/* Never re-arming READY fails the challenge like any other +* unserviced command; report it as such rather than as a bus +* timeout the bus never saw. +*/ +if (rb == -ETIMEDOUT ) + rb = -ENXIO ; +if (rb <0 ) +return rb; +if (dat <0 ) +return dat; +if (ret <0 ) +return ret; +if ((u16 )dat !=MXL862XX_SB_PDI_RDREG_MARK ) { +WRITE_ONCE (priv->rescue_ready, true); +return MXL862XX_IN_RESCUE ; + } +/* READY but the marker is untouched, so nothing is servicing the +* mailbox. A firmware publishing 0xc55c as its status word looks +* exactly like this, and flashing one would be far worse than +* refusing to bind, so treat it as unusable. +*/ +return -ENXIO ; + } + +/* The download handshake lives in STAT too and outlives a mailbox +* reset, so an aborted transfer leaves the loader waiting for a +* header no later session can supply: only a power cycle clears it. +*/ +if ((u16 )stat ==MXL862XX_SB_PDI_START || + (u16 )stat ==MXL862XX_SB_PDI_START +1 ) { +WRITE_ONCE (priv->rescue_failed, true); +return MXL862XX_IN_RESCUE ; + } + +/* Any other non-zero value is a running firmware, not a loader -- but +* the loader also holds the count of a chunk it is still programming, +* so let a caller that has ruled the firmware out wait that out. +*/ +if (stat) { +if (!settle) +return MXL862XX_NOT_RESCUE ; + + stat =mxl862xx_sb_pdi_poll_drain (priv, +MXL862XX_SB_PDI_STEP_MS ); +if (stat <0 ) +return stat; +if (stat ==MXL862XX_SB_PDI_READY ) { +WRITE_ONCE (priv->rescue_ready, true); +return MXL862XX_IN_RESCUE ; + } +if (stat) +return MXL862XX_NOT_RESCUE ; + } + +/* STAT == 0: a wedged receive loop takes a 1-byte slice-advance (feed +* one DATA word first, like a drain chunk) and asks for the next chunk +* by publishing 0 again. Had that byte been the last one outstanding, +* the loader leaves the loop instead and returns to READY, having +* consumed the advance -- proof enough of a live mailbox to skip the +* challenge. Anything else means it is still working on it. All three +* are rescue, so this never fails probe; only the drain does. +*/ + ret =mxl862xx_smdio_write (priv,MXL862XX_SB_PDI_CTRL , +MXL862XX_SB_PDI_CTRL_WR ); +if (ret <0 ) +return ret; + ret =mxl862xx_smdio_write (priv,MXL862XX_SB_PDI_DATA ,0x0000 ); +if (ret <0 ) +return ret; + ret =mxl862xx_sb_pdi_reset (priv); +if (ret <0 ) +return ret; + ret =mxl862xx_smdio_write (priv,MXL862XX_SB_PDI_STAT , +MXL862XX_DRAIN_CHUNK_BYTES ); +if (ret <0 ) +return ret; + + rb =mxl862xx_sb_pdi_poll_drain (priv,MXL862XX_SB_PDI_STEP_MS ); +if (rb <0 ) +return rb; +if (rb ==MXL862XX_SB_PDI_READY ) +WRITE_ONCE (priv->rescue_ready, true); + +return MXL862XX_IN_RESCUE ; +} +/* MCUboot firmware image header */ struct mxl862xx_fw_hdr {__le32 image_type;
@@ -294,13 +706,15 @@ static int mxl862xx_flash_firmware(struct mxl862xx_priv *priv,int ret, i;/* Step 1: reboot the firmware into MCUboot rescue mode */ - ret =mxl862xx_api_wrap (priv,SYS_MISC_FW_UPDATE ,NULL ,0 , - false, false); -if (ret) { -dev_err (&priv->mdiodev->dev, -"flash: FW_UPDATE command failed: %pe\n" , -ERR_PTR (ret)); -return ret; +if (!READ_ONCE (priv->rescue_mode)) { + ret =mxl862xx_api_wrap (priv,SYS_MISC_FW_UPDATE ,NULL ,0 , + false, false); +if (ret) { +dev_err (&priv->mdiodev->dev, +"flash: FW_UPDATE command failed: %pe\n" , +ERR_PTR (ret)); +return ret; + } }/* Step 2: wait for bootloader ready */
@@ -487,6 +901,25 @@ int mxl862xx_devlink_info_get(struct dsa_switch *ds,char buf[16 ];int ret; +/* No chip-id/revision in MCUboot (needs the firmware MMD mailbox). The +* fw version doubles as the "ready to flash" signal: report it only +* once the loader is at a clean READY, nothing while still draining. +*/ +if (READ_ONCE (priv->rescue_mode)) { +if (!READ_ONCE (priv->rescue_ready)) +return 0 ; + +snprintf (buf,sizeof (buf),"%u.%u.%u" , + priv->fw_version.major, priv->fw_version.minor, + priv->fw_version.revision); + ret =devlink_info_version_running_put (req, +DEVLINK_INFO_VERSION_GENERIC_FW , buf); +if (ret) +return ret; +return devlink_info_version_stored_put (req, +DEVLINK_INFO_VERSION_GENERIC_FW , buf); + } +/* A 0 part number means the CHIP ID read failed or the part is * unfused; omit it rather than publish a bogus "0000" that fwupd * would match firmware against -- it then falls back to the driver
@@ -559,9 +992,28 @@ int mxl862xx_devlink_flash_update(struct dsa_switch *ds,return ret; } -dev_info (ds->dev,"flash: running firmware %u.%u.%u\n" , - priv->fw_version.major, priv->fw_version.minor, - priv->fw_version.revision); +/* Refuse to flash while the background self-heal is still draining, and +* for good once it has given up on the loader. +*/ +if (READ_ONCE (priv->rescue_failed)) { +NL_SET_ERR_MSG_MOD (extack, +"download recovery failed, power cycle the switch" ); +return -EIO ; + } + +if (READ_ONCE (priv->rescue_mode) && !READ_ONCE (priv->rescue_ready)) { +NL_SET_ERR_MSG_MOD (extack, +"switch is recovering an interrupted download, retry shortly" ); +return -EBUSY ; + } + +if (READ_ONCE (priv->rescue_mode)) +dev_info (ds->dev, +"flash: flashing switch via MCUboot rescue mode\n" ); +else +dev_info (ds->dev,"flash: running firmware %u.%u.%u\n" , + priv->fw_version.major, priv->fw_version.minor, + priv->fw_version.revision);/* Close ports while the firmware is still alive so the DSA core's * MDB/FDB tracking is drained, and detach user ports so userspace
@@ -608,6 +1060,7 @@ int mxl862xx_devlink_flash_update(struct dsa_switch *ds,* readiness poll below read the freshly booted firmware. */ priv->flash_owner = current; +WRITE_ONCE (priv->rescue_mode, false);mutex_unlock (&priv->mdiodev->bus->mdio_lock);/* Refresh the cached versions so the flash update only
drivers/net/dsa/mxl862xx/mxl862xx-fw.h +3 -0
@@ -6,7 +6,10 @@#include <net/dsa.h> struct mxl862xx_priv ; +struct work_struct ; +int mxl862xx_rescue_mode_detect (struct mxl862xx_priv *priv,bool settle); +void mxl862xx_rescue_heal_work_fn (struct work_struct *work);int mxl862xx_devlink_info_get (struct dsa_switch *ds,struct devlink_info_req *req,struct netlink_ext_ack *extack);
drivers/net/dsa/mxl862xx/mxl862xx-host.c +8 -0
@@ -17,6 +17,7 @@#include <net/dsa.h> #include "mxl862xx.h" #include "mxl862xx-cmd.h" +#include "mxl862xx-fw.h" #include "mxl862xx-host.h" #define CTRL_BUSY_MASK BIT(15)
@@ -347,6 +348,11 @@ int mxl862xx_api_wrap(struct mxl862xx_priv *priv, u16 cmd, void *_data, goto out; } +if (priv->rescue_mode) { + ret = -ENODEV ; + goto out; + } +/* During the post-flash readiness poll block_host stays set, but the * flash path's own firmware version reads must reach the new image; * host writes stay blocked so stale resource IDs cannot corrupt it.
@@ -555,9 +561,11 @@ int mxl862xx_smdio_write(struct mxl862xx_priv *priv, u32 addr, u16 val)void mxl862xx_host_init (struct mxl862xx_priv *priv) {INIT_WORK (&priv->crc_err_work, mxl862xx_crc_err_work_fn); +INIT_WORK (&priv->rescue_heal_work, mxl862xx_rescue_heal_work_fn); }void mxl862xx_host_shutdown (struct mxl862xx_priv *priv) {cancel_work_sync (&priv->crc_err_work); +cancel_work_sync (&priv->rescue_heal_work); }
drivers/net/dsa/mxl862xx/mxl862xx-phylink.c +2 -0
@@ -406,6 +406,8 @@ mxl862xx_phylink_mac_select_pcs(struct phylink_config *config,switch (port) { case 9 ... 16: +if (READ_ONCE (priv->rescue_mode)) +return NULL ;if (!MXL862XX_FW_VER_MIN (priv,1 ,0 ,84 )) {dev_warn_once (dp->ds->dev,"SerDes PCS unsupported on old firmware.\n" );
drivers/net/dsa/mxl862xx/mxl862xx.c +83 -16
149 lines not on this page · raw message
drivers/net/dsa/mxl862xx/mxl862xx.h +20 -0
@@ -4,7 +4,9 @@#define __MXL862XX_H#include <asm/byteorder.h> +#include <linux/bitops.h> #include <linux/mdio.h> +#include <linux/mutex.h> #include <linux/workqueue.h> #include <net/dsa.h>
@@ -14,6 +16,10 @@ struct mxl862xx_priv;#define MXL862XX_FIRST_SERDES_PORT 9#define MXL862XX_SERDES_SLOTS 4 +/* mxl862xx_rescue_mode_detect() return codes (negative values are errors) */ +#define MXL862XX_NOT_RESCUE 0 +#define MXL862XX_IN_RESCUE 1 +#define MXL862XX_DEFAULT_BRIDGE 0#define MXL862XX_MAX_BRIDGES 48#define MXL862XX_MAX_BRIDGE_PORTS 128
@@ -329,6 +335,16 @@ struct mxl862xx_fw_version {* own firmware reads pass block_host * @skip_teardown: discard firmware API commands during the teardown * triggered by the post-flash reprobe +* @rescue_mode: switch is in MCUboot; firmware API commands fail fast, +* only clause-22 SMDIO works. Set from setup() before the +* switch is registered and cleared with WRITE_ONCE() under +* the MDIO bus lock for the benefit of mxl862xx_api_wrap(); +* readers outside that lock use READ_ONCE(). +* @rescue_ready: (rescue_mode) loader is at a clean READY and will accept +* a flash; false while rescue_heal_work is draining +* @rescue_failed: (rescue_mode) the self-heal gave up or cannot run; the +* loader needs a power cycle and no flash can be accepted +* @rescue_heal_work: background self-heal draining a wedged download to READY * @stats_work: periodic work item that polls RMON hardware counters * and accumulates them into 64-bit per-port stats */
@@ -336,6 +352,7 @@ struct mxl862xx_priv {struct dsa_switch *ds;struct mdio_device *mdiodev;struct work_struct crc_err_work; +struct work_struct rescue_heal_work;unsigned long flags;u16 drop_meter;struct mxl862xx_fw_version fw_version;
@@ -352,6 +369,9 @@ struct mxl862xx_priv {struct task_struct *flash_owner;bool block_host;bool skip_teardown; +bool rescue_mode; +bool rescue_ready; +bool rescue_failed;struct delayed_work stats_work; };
Signature · 1 line
2.55.0
Daniel Golle
maintainerPATCH v15 6/6 net: dsa: mxl862xx: document devlink flash and info support
In reply to Daniel GolleDescribe the devlink info versions and the flash update behaviour, including the MCUboot rescue mode recovery, in a dedicated file under Documentation/networking/devlink/ and link it from the index. Add the new file to the driver's MAINTAINERS entry.
---
v15:
- asic.rev is read from the CHIP ID registers as well, not from one register word shared with asic.id (found by Sashiko AI review)
- -EIO says the driver gave up on the recovery, which may need a driver rebind rather than a power cycle, and an interrupted opening handshake is reported the same way (found by Sashiko AI review)
v14: no changes
v13: no changes
v12: no changes
v11: no changes
v10: document that a switch power cycled on its own needs the driver
unbound and rebound before a failed recovery is re-examined
v9: no changes, picked up Andrew's v5 Reviewed-by
v8:
- asic.id and asic.rev are omitted whenever the part number reads zero, not only in MCUboot rescue mode (found by Sashiko AI review)
- drop the claim that "0.0.0" marks a switch that never ran firmware; rescue mode always reports it (found by Sashiko AI review)
- document devlink dev flash as the signal that says whether a recovery is still running, including the -EIO it returns once the recovery has failed (found by Sashiko AI review)
v7: no changes
v6: no changes
v5: new patch, splitting the devlink documentation out of the flash
update and rescue mode recovery patches so each keeps to code (Jakub Kicinski asked for the documentation)
Documentation/networking/devlink/index.rst | 1 + Documentation/networking/devlink/mxl862xx.rst | 81 +++++++++++++++++++ MAINTAINERS | 1 + 3 files changed, 83 insertions(+) create mode 100644 Documentation/networking/devlink/mxl862xx.rst
Documentation/networking/devlink/index.rst +1 -0
@@ -95,6 +95,7 @@ parameters, info versions, and other features it supports. mlx5 mlxsw mv88e6xxx + mxl862xx netdevsim nfp octeontx2
Documentation/networking/devlink/mxl862xx.rst new file +81 -0
81 lines not on this page · raw message
MAINTAINERS +1 -0
@@ -16246,6 +16246,7 @@ M: Daniel Golle <[email protected]> L: [email protected] S: Maintained F: Documentation/devicetree/bindings/net/dsa/maxlinear,mxl862xx.yaml +F: Documentation/networking/devlink/mxl862xx.rst F: drivers/net/dsa/mxl862xx/ F: net/dsa/tag_mxl862xx.c
Signature · 1 line
2.55.0