net: sfp: extend SMBus support
Subsystems (4)
v11 cover net: sfp: extend SMBus support
Today, the SFP driver only drives I2C adapters that advertise full I2C_FUNC_I2C, or SMBus-only adapters via single-byte transfers (with hwmon disabled). Several SoCs ship I2C/SMBus-only controllers that support more than just byte access -- e.g. word and I2C block -- and have SFP cages wired to them. Today, those adapters either work poorly or not at all.
This series teaches the SFP driver to use the larger SMBus access modes when the adapter advertises them, and along the way starts honoring i2c_adapter quirks on read/write length so adapters that cap below the SFP block size are handled correctly. Patch 1 is a small prep doing only the quirks handling; patch 2 extends the SMBus path itself.
Capability matrix supported by patch 2:
- BYTE only: single-byte access (unchanged). - BYTE + WORD: word for >=2-byte chunks, byte tail. - I2C_BLOCK present: block as the universal transport. - WORD only (no BYTE/BLOCK): accepted with WARN_ONCE; works for
even-length transfers, odd-length transfers will error at xfer time.
Adapters with asymmetric R/W capabilities (e.g. only READ_I2C_BLOCK without WRITE_I2C_BLOCK) remain functionally correct but use the worse-supported direction's max for both directions, since i2c_max_block_size is a single field. No mainline I2C driver was seen advertising such asymmetry; per-direction sizes can be added later if needed.
Note:
Sashiko keeps raising an issue about the write_len cap possibly limiting reads too harsh and disabling hwmon functionality although not needed. This is theoretically true but I've acknowledged this in the past versions multiple times, being rather theoretical because no in-tree drivers will trigger this.
---
v10 -> v11:
- use smbus_data.block[0] instead of this_len to address issue flagged by Sashiko in patch 2 [7]
- dropped Reviewed-by from Maxime on patch 2 due to changes
v10: https://lore.kernel.org/netdev/[email protected]/
v9 -> v10:
- dropped accepted and merged precursor patch
- resend as requested by Jakub
- added Reviewed-By from Maxime to first patch
- acknowledged potential issue flagged by Sashika, impact is theoretical, see [6]
v9: https://lore.kernel.org/netdev/[email protected]/
v8 -> v9:
- added precursor patch to mitigate issue flagged by Jakub's AI [3]
- issue flagged in [4] acknowledged in [5] but not fixed, due to no practical impact
- added Reviewed-By from Maxime to patch 3 (was patch 2 before)
v8: https://lore.kernel.org/netdev/[email protected]/
v7 -> v8:
- avoid leaking uninitialized memory on short reads by zero-initializing i2c_smbus_data variable (Simon)
- theoretical issue without practical impact raised at [1]
not addressed but acknowledged at [2]
v7: https://lore.kernel.org/netdev/[email protected]/
v6 -> v7:
- use i2c_block_size instead of i2c_max_block_size (Maxime)
- move WARN_ONCE into 'else if ()' (Maxime)
- reword comments
- included Maxime's Reviewed-by for patch 1
v6: https://lore.kernel.org/netdev/[email protected]/
v5 -> v6:
- Split adapter-quirks handling into a separate prep patch (1/2).
- Use I2C_SMBUS_I2C_BLOCK_DATA in the block-write branch (was I2C_SMBUS_WORD_DATA), so block writes actually transfer this_len bytes (also flagged by Jakub's AI bot review).
- In sfp_smbus_read/write, check i2c_smbus_xfer() return before copying smbus_data into the caller's buffer.
- Use I2C_BLOCK as the universal transport when available (carries any length 1..32); drop the this_len > 2 guard on the block branches.
- Broaden the SMBus gate to also accept BLOCK-only adapters
(Russell).
- Accept word-only adapters with WARN_ONCE rather than rejecting them (Andrew).
- Add a short comment in sfp_i2c_configure() explaining the access hierarchy (Maxime).
- Use the all-bits-set form via i2c_check_functionality() for the composite I2C_FUNC_SMBUS_* checks (Russell).
v5: https://lore.kernel.org/netdev/[email protected]/
v4 -> v5:
- made a more general approach, also covering word access
v4: https://lore.kernel.org/netdev/[email protected]/
v3 -> v4:
- fix formal issues
v3: https://lore.kernel.org/netdev/[email protected]/
v2 -> v3:
- fix previous attempt of v2 to fix return value
v2: https://lore.kernel.org/netdev/[email protected]/
v1 -> v2:
- return number of written bytes instead of zero
v1: https://lore.kernel.org/netdev/[email protected]/
[1] https://lore.kernel.org/netdev/[email protected]/
[2] https://lore.kernel.org/netdev/[email protected]/
[3] https://lore.kernel.org/netdev/[email protected]/
[4] https://lore.kernel.org/netdev/[email protected]/
[5] https://lore.kernel.org/netdev/[email protected]/
[6] https://lore.kernel.org/netdev/[email protected]/
[7] https://sashiko.dev/#/patchset/20260612142840.462664-1-jelonek.jonas%40gmail.com
---
Jonas Jelonek (2):
net: sfp: apply I2C adapter quirks to limit block size
net: sfp: extend SMBus support
drivers/net/phy/sfp.c | 149 ++++++++++++++++++++++++++++++++++-------- 1 file changed, 120 insertions(+), 29 deletions(-)
base-commit: 383bad5ffeb8a84fcb4b87544429edb82aa5d223
Signature · 1 line
2.51.0
PATCH v11 1/2 net: sfp: apply I2C adapter quirks to limit block size
The SFP driver assumes all I2C adapters support reading and writing the pre-defined block size SFP_EEPROM_BLOCK_SIZE of 16 bytes. This constant was probably chosen based on good guesses and known limitations of a range of I2C adapters and SFP modules.
However, I2C adapters may even support less and usually need to specify this via I2C quirks. Theoretically, such an adapter may provide full functionality but only support a read and write length of e.g. 8 bytes. Currently, the SFP driver doesn't account for that.
Add handling for I2C quirks in SFP I2C configuration taking the fields max_read_len and max_write_len in struct i2c_adapter_quirks into account to further limit the maximum block size if needed.
--- drivers/net/phy/sfp.c | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-)
drivers/net/phy/sfp.c +10 -2
@@ -810,21 +810,29 @@ static int sfp_smbus_byte_write(struct sfp *sfp, bool a2, u8 dev_addr,static int sfp_i2c_configure (struct sfp *sfp,struct i2c_adapter *i2c) { +size_t max_block_size; + sfp->i2c = i2c;if (i2c_check_functionality (i2c,I2C_FUNC_I2C )) { sfp->read = sfp_i2c_read; sfp->write = sfp_i2c_write; - sfp->i2c_max_block_size =SFP_EEPROM_BLOCK_SIZE ; + max_block_size =SFP_EEPROM_BLOCK_SIZE ; }else if (i2c_check_functionality (i2c,I2C_FUNC_SMBUS_BYTE_DATA )) { sfp->read = sfp_smbus_byte_read; sfp->write = sfp_smbus_byte_write; - sfp->i2c_max_block_size =1 ; + max_block_size =1 ; }else { sfp->i2c =NULL ;return -EINVAL ; } +if (i2c->quirks && i2c->quirks->max_read_len) + max_block_size =min (max_block_size, i2c->quirks->max_read_len); +if (i2c->quirks && i2c->quirks->max_write_len) + max_block_size =min (max_block_size, i2c->quirks->max_write_len); + + sfp->i2c_max_block_size = max_block_size; sfp->i2c_block_size = sfp->i2c_max_block_size;return 0 ; }
Signature · 1 line
2.51.0
PATCH v11 2/2 net: sfp: extend SMBus support
In reply to Jonas JelonekCommit 7662abf4db94 ("net: phy: sfp: Add support for SMBus module access") added SMBus access for SFP modules, but limited it to single-byte transfers. As a side effect, hwmon is disabled (16-bit reads cannot be guaranteed atomic) and a warning is printed.
Many SMBus-only I2C controllers in the wild support more than just byte access, and SFP cages are often wired to such controllers rather than to a full-featured I2C controller -- e.g. the SMBus controllers in the Realtek longan and mango SoCs, which advertise word access and I2C block reads. Today, they cannot drive an SFP at all without falling back to the byte-only path.
Extend sfp_smbus_read()/sfp_smbus_write() so that, in addition to the existing byte access, they also use SMBus word access and SMBus I2C block access whenever the adapter advertises them. Both directions are handled in a single read and a single write helper that pick the largest supported transfer per chunk and fall back as needed.
I2C-block is preferred unconditionally when available: the protocol carries any length 1..32, so it can serve every chunk -- including the 1- and 2-byte tails -- without help from word or byte access. Note that this requires I2C_FUNC_SMBUS_I2C_BLOCK, which reads a caller-specified number of bytes. This deviates from the official SMBus Block Read (length is supplied by the slave) but is widely supported by Linux I2C controllers/drivers.
Capability matrix this implementation supports:
- BYTE only: works (unchanged behaviour); 1-byte
xfers, hwmon disabled.
- BYTE + WORD: word for >=2-byte chunks, byte for
trailing odd byte.
- I2C_BLOCK present (with or
without BYTE/WORD): block as the universal transport for
every chunk.
- WORD only (no BYTE/BLOCK): accepted with WARN_ONCE. Even-length transfers work; odd-length transfers (e.g. the 3-byte cotsworks fixup write) hit the BYTE branch which the adapter does not implement, so the xfer returns an error and the operation is aborted. No mainline I2C driver was found to advertise WORD without BYTE; the warning lets us learn about it if it ever shows up.
Adapters with asymmetric R/W capabilities (e.g. only READ_I2C_BLOCK but not WRITE_I2C_BLOCK) remain functionally correct -- the per-iteration fallback uses the direction-specific bits -- but the shared i2c_max_block_size is sized by the all-bits-set check, so a transfer in the better-supported direction is not upgraded. None of the mainline I2C bus drivers surveyed during review advertise such asymmetry; promoting i2c_max_block_size to per-direction sizes can be revisited if needed.
--- drivers/net/phy/sfp.c | 139 +++++++++++++++++++++++++++++++++--------- 1 file changed, 111 insertions(+), 28 deletions(-)
drivers/net/phy/sfp.c +111 -28
@@ -14,6 +14,7 @@#include <linux/platform_device.h> #include <linux/rtnetlink.h> #include <linux/slab.h> +#include <linux/unaligned.h> #include <linux/workqueue.h> #include "sfp.h"
@@ -759,50 +760,113 @@ static int sfp_i2c_write(struct sfp *sfp, bool a2, u8 dev_addr, void *buf,return ret ==ARRAY_SIZE (msgs) ? len :0 ; } -static int sfp_smbus_byte_read (struct sfp *sfp,bool a2,u8 dev_addr, -void *buf,size_t len) +static int sfp_smbus_read (struct sfp *sfp,bool a2,u8 dev_addr,void *buf, +size_t len) { -union i2c_smbus_data smbus_data; +union i2c_smbus_data smbus_data = {0 };u8 bus_addr = a2 ?0x51 :0x50 ; +size_t this_len, transferred; +u32 functionality;u8 *data = buf;int ret; -while (len) { - ret =i2c_smbus_xfer (sfp->i2c, bus_addr,0 , -I2C_SMBUS_READ , dev_addr, -I2C_SMBUS_BYTE_DATA , &smbus_data); -if (ret <0 ) -return ret; + functionality =i2c_get_functionality (sfp->i2c); - *data = smbus_data.byte; +while (len) { + this_len =min (len, sfp->i2c_block_size); + +if (functionality &I2C_FUNC_SMBUS_READ_I2C_BLOCK ) { + smbus_data.block[0 ] = this_len; + ret =i2c_smbus_xfer (sfp->i2c, bus_addr,0 , +I2C_SMBUS_READ , dev_addr, +I2C_SMBUS_I2C_BLOCK_DATA , &smbus_data); +if (ret <0 ) +return ret; + + transferred =min_t (size_t, smbus_data.block[0 ], this_len); +if (!transferred) +return -EIO ; + +memcpy (data, &smbus_data.block[1 ], transferred); + }else if (this_len >=2 && + (functionality &I2C_FUNC_SMBUS_READ_WORD_DATA )) { + ret =i2c_smbus_xfer (sfp->i2c, bus_addr,0 , +I2C_SMBUS_READ , dev_addr, +I2C_SMBUS_WORD_DATA , &smbus_data); +if (ret <0 ) +return ret; + +put_unaligned_le16 (smbus_data.word, data); + transferred =2 ; + }else { + ret =i2c_smbus_xfer (sfp->i2c, bus_addr,0 , +I2C_SMBUS_READ , dev_addr, +I2C_SMBUS_BYTE_DATA , &smbus_data); +if (ret <0 ) +return ret; + + *data = smbus_data.byte; + transferred =1 ; + } - len--; - data++; - dev_addr++; + data += transferred; + len -= transferred; + dev_addr += transferred; }return data - (u8 *)buf; } -static int sfp_smbus_byte_write (struct sfp *sfp,bool a2,u8 dev_addr, -void *buf,size_t len) +static int sfp_smbus_write (struct sfp *sfp,bool a2,u8 dev_addr,void *buf, +size_t len) {union i2c_smbus_data smbus_data;u8 bus_addr = a2 ?0x51 :0x50 ; +size_t this_len, transferred; +u32 functionality;u8 *data = buf;int ret; + functionality =i2c_get_functionality (sfp->i2c); +while (len) { - smbus_data.byte = *data; - ret =i2c_smbus_xfer (sfp->i2c, bus_addr,0 , -I2C_SMBUS_WRITE , dev_addr, -I2C_SMBUS_BYTE_DATA , &smbus_data); -if (ret) -return ret; + this_len =min (len, sfp->i2c_block_size); + +if (functionality &I2C_FUNC_SMBUS_WRITE_I2C_BLOCK ) { + smbus_data.block[0 ] = this_len; +memcpy (&smbus_data.block[1 ], data, this_len); + + ret =i2c_smbus_xfer (sfp->i2c, bus_addr,0 , +I2C_SMBUS_WRITE , dev_addr, +I2C_SMBUS_I2C_BLOCK_DATA , &smbus_data); +if (ret <0 ) +return ret; + + transferred = this_len; + }else if (this_len >=2 && + (functionality &I2C_FUNC_SMBUS_WRITE_WORD_DATA )) { + smbus_data.word =get_unaligned_le16 (data); + ret =i2c_smbus_xfer (sfp->i2c, bus_addr,0 , +I2C_SMBUS_WRITE , dev_addr, +I2C_SMBUS_WORD_DATA , &smbus_data); +if (ret <0 ) +return ret; + + transferred =2 ; + }else { + smbus_data.byte = *data; + ret =i2c_smbus_xfer (sfp->i2c, bus_addr,0 , +I2C_SMBUS_WRITE , dev_addr, +I2C_SMBUS_BYTE_DATA , &smbus_data); +if (ret <0 ) +return ret; + + transferred =1 ; + } - len--; - data++; - dev_addr++; + data += transferred; + len -= transferred; + dev_addr += transferred; }return data - (u8 *)buf;
@@ -818,10 +882,29 @@ static int sfp_i2c_configure(struct sfp *sfp, struct i2c_adapter *i2c) sfp->read = sfp_i2c_read; sfp->write = sfp_i2c_write; max_block_size =SFP_EEPROM_BLOCK_SIZE ; - }else if (i2c_check_functionality (i2c,I2C_FUNC_SMBUS_BYTE_DATA )) { - sfp->read = sfp_smbus_byte_read; - sfp->write = sfp_smbus_byte_write; - max_block_size =1 ; + }else if (i2c_check_functionality (i2c,I2C_FUNC_SMBUS_BYTE_DATA ) || +i2c_check_functionality (i2c,I2C_FUNC_SMBUS_I2C_BLOCK )) { +/* Either protocol alone covers any length: I2C-block carries +* 1..32 bytes per xfer, byte iterates one byte at a time. +*/ + sfp->read = sfp_smbus_read; + sfp->write = sfp_smbus_write; + +if (i2c_check_functionality (i2c,I2C_FUNC_SMBUS_I2C_BLOCK )) + max_block_size =SFP_EEPROM_BLOCK_SIZE ; +else if (i2c_check_functionality (i2c,I2C_FUNC_SMBUS_WORD_DATA )) + max_block_size =2 ; +else + max_block_size =1 ; + }else if (WARN_ONCE (i2c_check_functionality (i2c,I2C_FUNC_SMBUS_WORD_DATA ), +"SMBus word-only adapter; odd-length transfers will fail\n" )) { +/* Word-only: even-length xfers work; odd-length xfers fall +* to BYTE, which the adapter does not advertise and will +* likely fail. +*/ + sfp->read = sfp_smbus_read; + sfp->write = sfp_smbus_write; + max_block_size =2 ; }else { sfp->i2c =NULL ;return -EINVAL ;
Signature · 1 line
2.51.0
Hi Jonas,
Quoted 57 lines · Jonas Jelonek
Commit
7662abf4db94("net: phy: sfp: Add support for SMBus module access") added SMBus access for SFP modules, but limited it to single-byte transfers. As a side effect, hwmon is disabled (16-bit reads cannot be guaranteed atomic) and a warning is printed.Many SMBus-only I2C controllers in the wild support more than just byte access, and SFP cages are often wired to such controllers rather than to a full-featured I2C controller -- e.g. the SMBus controllers in the Realtek longan and mango SoCs, which advertise word access and I2C block reads. Today, they cannot drive an SFP at all without falling back to the byte-only path.
Extend sfp_smbus_read()/sfp_smbus_write() so that, in addition to the existing byte access, they also use SMBus word access and SMBus I2C block access whenever the adapter advertises them. Both directions are handled in a single read and a single write helper that pick the largest supported transfer per chunk and fall back as needed.
I2C-block is preferred unconditionally when available: the protocol carries any length 1..32, so it can serve every chunk -- including the 1- and 2-byte tails -- without help from word or byte access. Note that this requires
I2C_FUNC_SMBUS_I2C_BLOCK, which reads a caller-specified number of bytes. This deviates from the official SMBus Block Read (length is supplied by the slave) but is widely supported by Linux I2C controllers/drivers.Capability matrix this implementation supports:
- BYTE only: works (unchanged behaviour); 1-byte
xfers, hwmon disabled.
- BYTE + WORD: word for >=2-byte chunks, byte for
trailing odd byte.
-I2C_BLOCKpresent (with or
without BYTE/WORD): block as the universal transport for
every chunk.
- WORD only (no BYTE/BLOCK): accepted withWARN_ONCE. Even-length transfers work; odd-length transfers (e.g. the 3-byte cotsworks fixup write) hit the BYTE branch which the adapter does not implement, so the xfer returns an error and the operation is aborted. No mainline I2C driver was found to advertise WORD without BYTE; the warning lets us learn about it if it ever shows up.Adapters with asymmetric R/W capabilities (e.g. only
READ_I2C_BLOCKbut notWRITE_I2C_BLOCK) remain functionally correct -- the per-iteration fallback uses the direction-specific bits -- but the sharedi2c_max_block_sizeis sized by the all-bits-set check, so a transfer in the better-supported direction is not upgraded. None of the mainline I2C bus drivers surveyed during review advertise such asymmetry; promotingi2c_max_block_sizeto per-direction sizes can be revisited if needed.
Quoted 1 line
Signed-off-by Jonas Jelonek <[email protected]>
Thanks for this work,
Maxime
This series was applied to netdev/net-next.git (main) by Jakub Kicinski <[email protected]>:
Hello:
This series was applied to netdev/net-next.git (main) by Jakub Kicinski <[email protected]>:
Quoted 8 lines · On Sun, 14 Jun 2026 13:34:16 +0000 you wrote:
Today, the SFP driver only drives I2C adapters that advertise full
I2C_FUNC_I2C, or SMBus-only adapters via single-byte transfers (with hwmon disabled). Several SoCs ship I2C/SMBus-only controllers that support more than just byte access -- e.g. word and I2C block -- and have SFP cages wired to them. Today, those adapters either work poorly or not at all.[...]
Here is the summary with links:
- [net-next,v11,1/2] net: sfp: apply I2C adapter quirks to limit block size
https://git.kernel.org/netdev/net-next/c/f2a138abfb71 - [net-next,v11,2/2] net: sfp: extend SMBus support https://git.kernel.org/netdev/net-next/c/58b29bdf6186
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html