tree cdba117e8f3ffc08b25c457cb9982f6931f1f1ed
parent 01a16664691a68e923a4f25cdcf0e4235134c4c3
author Christian Marangi <ansuelsmth@gmail.com> 1744056106 +0200
committer Tom Rini <trini@konsulko.com> 1744843905 -0600

net: airoha: Add Airoha Ethernet driver

Add airoha Ethernet driver for Airoha AN7581 SoC. This is a majorly
rewritten and simplified version of the Linux airoha_eth.c driver.

It's has been modified to support a single RX/TX ring to reflect U-Boot
implementation with recv and send API.

The struct and the define are kept as similar as possible to upstream
one to not diverge too much.

The AN7581 SoC include an Ethernet Switch based on the Mediatek MT753x
but doesn't require any modification aside from setting the CPU port and
applying the Flood configuration hence it can be handled entirely in the
Ethernet driver.

Signed-off-by: Christian Marangi <ansuelsmth@gmail.com>
