tree e23801926a46e28e2b198f30dd6af93025c3f1ff
parent e19f40377078375ed85f27e5028ed17d7857d6ca
author Mario Scheithauer <mario.scheithauer@siemens.com> 1669044123 +0100
committer Martin L Roth <gaumless@gmail.com> 1669269818 +0000

drivers/net/phy/m88e1512: Add downshift enable

This patch provides the functionality to enable downshift on Marvell
PHY. By setting a downshift counter, the PHY is correspondingly often
attempted to establish Gigabit link before the PHY downshifts to the
next highest speed. The range is limited to 8 trials. To activate
downshift, a software reset must follow to take effect.

Change-Id: I4224eab6c1fc13824d53556c80435bc130a13bdb
Signed-off-by: Mario Scheithauer <mario.scheithauer@siemens.com>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/69853
Reviewed-by: Arthur Heymans <arthur@aheymans.xyz>
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
