From: David Bauer Date: Sun, 2 May 2021 22:08:38 +0000 (+0200) Subject: ramips: backport unlocked mdiobus accessors X-Git-Tag: v19.07.8~24 X-Git-Url: http://git.openwrt.org/?p=openwrt%2Fopenwrt.git;a=commitdiff_plain;h=08ef2073d416214a0f7edf02aefa32d4107e4c1c;ds=inline ramips: backport unlocked mdiobus accessors Commit 718e97c5c843 ("ramips: mt7530 swconfig: fix race condition in register access") backports a fix which depends on unlocked MMD accessors, however these were not yet included in Kernel 4.14 and they were not backported yet. Fixes commit 718e97c5c843 ("ramips: mt7530 swconfig: fix race condition in register access") Signed-off-by: David Bauer --- diff --git a/target/linux/ramips/patches-4.14/700-net-mdiobus-add-unlocked-accessors.patch b/target/linux/ramips/patches-4.14/700-net-mdiobus-add-unlocked-accessors.patch new file mode 100644 index 0000000000..4880c49b13 --- /dev/null +++ b/target/linux/ramips/patches-4.14/700-net-mdiobus-add-unlocked-accessors.patch @@ -0,0 +1,141 @@ +From b2b8b06f18281c637da274b18e330bc52351637e Mon Sep 17 00:00:00 2001 +From: Russell King +Date: Tue, 2 Jan 2018 10:58:27 +0000 +Subject: [PATCH] net: mdiobus: add unlocked accessors + +commit 34dc08e4be208539b7c4aa8154a610e1736705e8 upstream. + +Add unlocked versions of the bus accessors, which allows access to the +bus with all the tracing. These accessors validate that the bus mutex +is held, which is a basic requirement for all mii bus accesses. + +Reviewed-by: Florian Fainelli +Signed-off-by: Russell King +Signed-off-by: David S. Miller +--- + drivers/net/phy/mdio_bus.c | 65 +++++++++++++++++++++++++++++++------- + include/linux/mdio.h | 3 ++ + 2 files changed, 56 insertions(+), 12 deletions(-) + +--- a/drivers/net/phy/mdio_bus.c ++++ b/drivers/net/phy/mdio_bus.c +@@ -493,6 +493,55 @@ struct phy_device *mdiobus_scan(struct m + EXPORT_SYMBOL(mdiobus_scan); + + /** ++ * __mdiobus_read - Unlocked version of the mdiobus_read function ++ * @bus: the mii_bus struct ++ * @addr: the phy address ++ * @regnum: register number to read ++ * ++ * Read a MDIO bus register. Caller must hold the mdio bus lock. ++ * ++ * NOTE: MUST NOT be called from interrupt context. ++ */ ++int __mdiobus_read(struct mii_bus *bus, int addr, u32 regnum) ++{ ++ int retval; ++ ++ WARN_ON_ONCE(!mutex_is_locked(&bus->mdio_lock)); ++ ++ retval = bus->read(bus, addr, regnum); ++ ++ trace_mdio_access(bus, 1, addr, regnum, retval, retval); ++ ++ return retval; ++} ++EXPORT_SYMBOL(__mdiobus_read); ++ ++/** ++ * __mdiobus_write - Unlocked version of the mdiobus_write function ++ * @bus: the mii_bus struct ++ * @addr: the phy address ++ * @regnum: register number to write ++ * @val: value to write to @regnum ++ * ++ * Write a MDIO bus register. Caller must hold the mdio bus lock. ++ * ++ * NOTE: MUST NOT be called from interrupt context. ++ */ ++int __mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val) ++{ ++ int err; ++ ++ WARN_ON_ONCE(!mutex_is_locked(&bus->mdio_lock)); ++ ++ err = bus->write(bus, addr, regnum, val); ++ ++ trace_mdio_access(bus, 0, addr, regnum, val, err); ++ ++ return err; ++} ++EXPORT_SYMBOL(__mdiobus_write); ++ ++/** + * mdiobus_read_nested - Nested version of the mdiobus_read function + * @bus: the mii_bus struct + * @addr: the phy address +@@ -512,11 +561,9 @@ int mdiobus_read_nested(struct mii_bus * + BUG_ON(in_interrupt()); + + mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED); +- retval = bus->read(bus, addr, regnum); ++ retval = __mdiobus_read(bus, addr, regnum); + mutex_unlock(&bus->mdio_lock); + +- trace_mdio_access(bus, 1, addr, regnum, retval, retval); +- + return retval; + } + EXPORT_SYMBOL(mdiobus_read_nested); +@@ -538,11 +585,9 @@ int mdiobus_read(struct mii_bus *bus, in + BUG_ON(in_interrupt()); + + mutex_lock(&bus->mdio_lock); +- retval = bus->read(bus, addr, regnum); ++ retval = __mdiobus_read(bus, addr, regnum); + mutex_unlock(&bus->mdio_lock); + +- trace_mdio_access(bus, 1, addr, regnum, retval, retval); +- + return retval; + } + EXPORT_SYMBOL(mdiobus_read); +@@ -568,11 +613,9 @@ int mdiobus_write_nested(struct mii_bus + BUG_ON(in_interrupt()); + + mutex_lock_nested(&bus->mdio_lock, MDIO_MUTEX_NESTED); +- err = bus->write(bus, addr, regnum, val); ++ err = __mdiobus_write(bus, addr, regnum, val); + mutex_unlock(&bus->mdio_lock); + +- trace_mdio_access(bus, 0, addr, regnum, val, err); +- + return err; + } + EXPORT_SYMBOL(mdiobus_write_nested); +@@ -595,11 +638,9 @@ int mdiobus_write(struct mii_bus *bus, i + BUG_ON(in_interrupt()); + + mutex_lock(&bus->mdio_lock); +- err = bus->write(bus, addr, regnum, val); ++ err = __mdiobus_write(bus, addr, regnum, val); + mutex_unlock(&bus->mdio_lock); + +- trace_mdio_access(bus, 0, addr, regnum, val, err); +- + return err; + } + EXPORT_SYMBOL(mdiobus_write); +--- a/include/linux/mdio.h ++++ b/include/linux/mdio.h +@@ -257,6 +257,9 @@ static inline u16 ethtool_adv_to_mmd_eee + return reg; + } + ++int __mdiobus_read(struct mii_bus *bus, int addr, u32 regnum); ++int __mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val); ++ + int mdiobus_read(struct mii_bus *bus, int addr, u32 regnum); + int mdiobus_read_nested(struct mii_bus *bus, int addr, u32 regnum); + int mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val);