Ethernet PHY & phylink
Donanım Ağ Katmanı

/* MAC sürücüsünde MDIO bus oluşturma */
static int my_mac_mdio_probe(struct platform_device *pdev)
{
    struct mii_bus *bus;
    int ret;

    bus = devm_mdiobus_alloc(&pdev->dev);
    if (!bus)
        return -ENOMEM;

    bus->name      = "my-mdio-bus";
    bus->read      = my_mdio_read;    /* Clause 22 okuma */
    bus->write     = my_mdio_write;   /* Clause 22 yazma */
    bus->read_c45  = my_mdio_read_c45;  /* Clause 45 — isteğe bağlı */
    bus->write_c45 = my_mdio_write_c45;
    bus->parent    = &pdev->dev;
    snprintf(bus->id, MII_BUS_ID_SIZE, "%s", pdev->name);

    ret = of_mdiobus_register(bus, pdev->dev.of_node);
    if (ret) {
        dev_err(&pdev->dev, "MDIO bus kaydı başarısız: %d\n", ret);
        return ret;
    }
    return 0;
}

/* Clause 22 okuma örneği */
static int my_mdio_read(struct mii_bus *bus, int phy_addr, int reg)
{
    struct my_priv *priv = bus->priv;
    u32 cmd, val;
    int timeout = 1000;

    cmd = MDIO_RD | ((phy_addr & 0x1f) << 21) | ((reg & 0x1f) << 16);
    writel(cmd, priv->base + MDIO_CMD);

    while (timeout-- && (readl(priv->base + MDIO_STATUS) & MDIO_BUSY))
        udelay(1);

    if (timeout < 0)
        return -ETIMEDOUT;

    val = readl(priv->base + MDIO_DATA);
    return val & 0xffff;
}

/* Kullanıcı alanından da mdio_read/write çağrılabilir */
/* Kernel içinde direkt: */
int val = mdiobus_read(bus, phy_addr, MII_BMSR);
mdiobus_write(bus, phy_addr, MII_ADVERTISE, ADVERTISE_ALL | ADVERTISE_PAUSE_CAP);

/* Clause 45: */
int val = mdiobus_c45_read(bus, phy_addr, MDIO_MMD_AN, MDIO_AN_ADVERTISE);
mdiobus_c45_write(bus, phy_addr, MDIO_MMD_PMAPMD, MDIO_CTRL1, MDIO_CTRL1_RESET);

/* MAC sürücüsünde PHY bağlantısı */
static void my_adjust_link(struct net_device *ndev)
{
    struct my_priv *priv = netdev_priv(ndev);
    struct phy_device *phydev = ndev->phydev;
    bool changed = false;

    if (priv->speed != phydev->speed) {
        priv->speed = phydev->speed;
        changed = true;
    }
    if (priv->duplex != phydev->duplex) {
        priv->duplex = phydev->duplex;
        changed = true;
    }

    if (changed || priv->link != phydev->link) {
        priv->link = phydev->link;
        if (phydev->link)
            my_mac_set_speed(priv, phydev->speed, phydev->duplex);
        else
            my_mac_link_down(priv);
        phy_print_status(phydev);
    }
}

static int my_open(struct net_device *ndev)
{
    struct my_priv *priv = netdev_priv(ndev);
    struct phy_device *phydev;

    phydev = of_phy_connect(ndev,
                            priv->phy_node,
                            my_adjust_link,
                            0,
                            PHY_INTERFACE_MODE_RGMII_ID);
    if (IS_ERR(phydev))
        return PTR_ERR(phydev);

    phy_start(phydev);
    return 0;
}

static int my_stop(struct net_device *ndev)
{
    phy_stop(ndev->phydev);
    phy_disconnect(ndev->phydev);
    return 0;
}

genphy_config_init(phydev);      /* Özellik maskesi — 1G/100M/10M */
genphy_config_aneg(phydev);      /* Auto-negotiation başlat */
genphy_update_link(phydev);      /* BMSR okunur, link durumu güncellenir */
genphy_read_status(phydev);      /* Hız, duplex, link durumu toplu güncelle */
genphy_restart_aneg(phydev);     /* Auto-neg yeniden başlat (BMCR ANRESTART) */
genphy_suspend(phydev);          /* PHY'yi güç tasarruf moduna al */
genphy_resume(phydev);           /* PHY'yi uyandır */

static void my_mac_validate(struct phylink_config *config,
                             unsigned long *supported,
                             struct phylink_link_state *state)
{
    __ETHTOOL_DECLARE_LINK_MODE_MASK(mask) = { 0, };

    /* MAC'in desteklediği modları belirt */
    phylink_set(mask, Autoneg);
    phylink_set(mask, Pause);
    phylink_set(mask, Asym_Pause);
    phylink_set_port_modes(mask);
    phylink_set(mask, 1000baseT_Full);
    phylink_set(mask, 100baseT_Full);
    phylink_set(mask, 10baseT_Half);
    phylink_set(mask, 10baseT_Full);

    if (state->interface == PHY_INTERFACE_MODE_RGMII ||
        state->interface == PHY_INTERFACE_MODE_RGMII_ID) {
        phylink_set(mask, 1000baseT_Full);
    }

    linkmode_and(supported, supported, mask);
    linkmode_and(state->advertising, state->advertising, mask);
}

static void my_mac_config(struct phylink_config *config, unsigned int mode,
                           const struct phylink_link_state *state)
{
    struct my_priv *priv = container_of(config, struct my_priv, phylink_config);
    /* Hız/duplex değiştiğinde MAC register'larını güncelle */
    my_mac_update_registers(priv, state->speed, state->duplex, state->pause);
}

static void my_mac_link_down(struct phylink_config *config, unsigned int mode,
                              phy_interface_t interface)
{
    struct my_priv *priv = container_of(config, struct my_priv, phylink_config);
    my_mac_disable_tx_rx(priv);
}

static void my_mac_link_up(struct phylink_config *config,
                            struct phy_device *phy,
                            unsigned int mode, phy_interface_t interface,
                            int speed, int duplex,
                            bool tx_pause, bool rx_pause)
{
    struct my_priv *priv = container_of(config, struct my_priv, phylink_config);
    my_mac_set_speed_duplex(priv, speed, duplex);
    my_mac_set_pause(priv, tx_pause, rx_pause);
    my_mac_enable_tx_rx(priv);
}

static const struct phylink_mac_ops my_phylink_ops = {
    .validate        = my_mac_validate,
    .mac_config      = my_mac_config,
    .mac_link_down   = my_mac_link_down,
    .mac_link_up     = my_mac_link_up,
};

static int my_probe(struct platform_device *pdev)
{
    struct my_priv *priv = /* ... */;
    struct phylink *pl;

    priv->phylink_config.dev = &ndev->dev;
    priv->phylink_config.type = PHYLINK_NETDEV;

    pl = phylink_create(&priv->phylink_config,
                        of_fwnode_handle(pdev->dev.of_node),
                        priv->phy_mode,
                        &my_phylink_ops);
    if (IS_ERR(pl))
        return PTR_ERR(pl);

    priv->phylink = pl;
    return 0;
}

/* ndo_open içinde */
phylink_start(priv->phylink);

/* ndo_stop içinde */
phylink_stop(priv->phylink);
phylink_disconnect_phy(priv->phylink);

/* drivers/net/phy/myvendor.c */
#include <linux/phy.h>
#include <linux/module.h>

/* Vendor PHY ID — PHYIDR1:PHYIDR2 register'larından alınır */
#define MYPHY_ID       0x0283BC30
#define MYPHY_ID_MASK  0xFFFFFFF0

/* Vendor özel register'lar */
#define MYPHY_EXT_CTRL       0x17
#define MYPHY_EXT_CTRL_CLKOUT  BIT(0)
#define MYPHY_LED_CTRL       0x18
#define MYPHY_LED_LINK_ACT   (0x6 << 4)

static int myphy_config_init(struct phy_device *phydev)
{
    int val, ret;

    /* Standart başlatma */
    ret = genphy_config_init(phydev);
    if (ret < 0)
        return ret;

    /* Enerji tasarruf modunu etkinleştir */
    val = phy_read(phydev, MYPHY_EXT_CTRL);
    if (val < 0)
        return val;

    val |= MYPHY_EXT_CTRL_CLKOUT;
    ret = phy_write(phydev, MYPHY_EXT_CTRL, val);
    if (ret)
        return ret;

    /* LED modunu ayarla: Link/Activity */
    ret = phy_write(phydev, MYPHY_LED_CTRL, MYPHY_LED_LINK_ACT);
    return ret;
}

static int myphy_read_status(struct phy_device *phydev)
{
    int ret;

    /* Standart okuma + vendor-specific durum 
     * Burada EEE (Energy Efficient Ethernet) kontrolü de yapılabilir */
    ret = genphy_read_status(phydev);
    if (ret)
        return ret;

    /* Vendor özel kablo tanısı — isteğe bağlı */
    phydev->mdix = ETH_TP_MDI_AUTO;
    return 0;
}

static int myphy_config_aneg(struct phy_device *phydev)
{
    /* Vendor özel ayarlar yapıldıktan sonra standart auto-neg */
    return genphy_config_aneg(phydev);
}

static struct phy_driver myphy_drivers[] = {
    {
        PHY_ID_MATCH_MODEL(MYPHY_ID),
        .name           = "MyVendor PHY",
        .features       = PHY_GBIT_FEATURES,
        .flags          = PHY_HAS_INTERRUPT,
        .config_init    = myphy_config_init,
        .config_aneg    = myphy_config_aneg,
        .read_status    = myphy_read_status,
        .ack_interrupt  = myphy_ack_interrupt,
        .config_intr    = myphy_config_intr,
        .suspend        = genphy_suspend,
        .resume         = genphy_resume,
    },
};

module_phy_driver(myphy_drivers);

static const struct mdio_device_id __maybe_unused myphy_tbl[] = {
    { MYPHY_ID, MYPHY_ID_MASK },
    { }
};
MODULE_DEVICE_TABLE(mdio, myphy_tbl);
MODULE_AUTHOR("Emirhan Pehlevan");
MODULE_DESCRIPTION("MyVendor PHY sürücüsü");
MODULE_LICENSE("GPL");

/* PHY interrupt kaynağını temizle (ack) */
static int myphy_ack_interrupt(struct phy_device *phydev)
{
    int val;
    /* Interrupt Status Register okunarak bit'ler temizlenir */
    val = phy_read(phydev, MYPHY_ISR);
    return (val < 0) ? val : 0;
}

/* Interrupt'ı etkinleştir/devre dışı bırak */
static int myphy_config_intr(struct phy_device *phydev)
{
    int val, ret;

    if (phydev->interrupts == PHY_INTERRUPT_ENABLED) {
        ret = myphy_ack_interrupt(phydev);
        if (ret)
            return ret;
        /* IMR register'ına link up/down mask'ı yaz */
        val = MYPHY_IMR_LINK_UP | MYPHY_IMR_LINK_DOWN;
        ret = phy_write(phydev, MYPHY_IMR, val);
    } else {
        ret = phy_write(phydev, MYPHY_IMR, 0);
        if (ret)
            return ret;
        ret = myphy_ack_interrupt(phydev);
    }
    return ret;
}

/* Yeni API: handle_interrupt (Linux 5.12+) */
static irqreturn_t myphy_handle_interrupt(struct phy_device *phydev)
{
    int irq_status;

    irq_status = phy_read(phydev, MYPHY_ISR);
    if (irq_status < 0) {
        phy_error(phydev);
        return IRQ_NONE;
    }

    if (!(irq_status & (MYPHY_ISR_LINK_UP | MYPHY_ISR_LINK_DOWN)))
        return IRQ_NONE;

    phy_trigger_machine(phydev);
    return IRQ_HANDLED;
}

/* Kernel kaynak: drivers/net/phy/phy_device.c */
int genphy_update_link(struct phy_device *phydev)
{
    int status, bmcr;

    bmcr = phy_read(phydev, MII_BMCR);
    if (bmcr < 0)
        return bmcr;

    /* Loopback modda link her zaman var */
    if (bmcr & BMCR_LOOPBACK) {
        phydev->link = 1;
        return 0;
    }

    /* Birinci okuma latch-low bit'i temizler */
    status = phy_read(phydev, MII_BMSR);
    if (status < 0)
        return status;

    /* İkinci okuma gerçek anlık değeri döndürür */
    status = phy_read(phydev, MII_BMSR);
    if (status < 0)
        return status;

    if (status & BMSR_LSTATUS)
        phydev->link = 1;
    else
        phydev->link = 0;
    return 0;
}

/* phylink oluşturduktan sonra SFP upstream kaydı */
static int my_probe(struct platform_device *pdev)
{
    struct my_priv *priv;
    struct sfp_bus *sfp_bus;
    int ret;

    /* ... phylink oluştur ... */

    /* Cihaz ağacında sfp = <&sfp_node> varsa otomatik bağlanır */
    ret = phylink_of_phy_connect(priv->phylink,
                                  pdev->dev.of_node, 0);
    if (ret)
        return ret;

    return 0;
}

/* Düşük seviyeli sfp_bus doğrudan kullanım (nadiren gerekir): */
sfp_bus = sfp_register_upstream(fwnode, &priv->phylink_config, upstream_ops);
if (IS_ERR(sfp_bus))
    return PTR_ERR(sfp_bus);
priv->sfp_bus = sfp_bus;

sfp0: sfp-connector {
    compatible = "sff,sfp";
    i2c-bus = <&i2c1>;
    los-gpios   = <&gpio 14 GPIO_ACTIVE_HIGH>;
    mod-def0-gpios = <&gpio 15 GPIO_ACTIVE_LOW>;
    tx-fault-gpios = <&gpio 16 GPIO_ACTIVE_HIGH>;
    tx-disable-gpios = <&gpio 17 GPIO_ACTIVE_HIGH>;
    maximum-power-milliwatt = <1000>;
};

&gmac0 {
    phy-mode = "sgmii";
    sfp = <&sfp0>;
    managed = "in-band-status";
};

/* MAC düğümü */
&gmac {
    status = "okay";
    phy-mode = "rgmii-id";          /* RGMII, MAC her iki gecikmeyi uygular */
    phy-handle = <&phy0>;          /* Hangi PHY'ye bağlı */
    pinctrl-names = "default";
    pinctrl-0 = <&gmac_pins>;
};

/* MDIO bus */
&mdio {
    status = "okay";
    /* PHY reset GPIO — zorunlu değil ama önerilir */
    reset-gpios = <&gpio 10 GPIO_ACTIVE_LOW>;
    reset-deassert-us = <10000>;
    reset-post-delay-us = <100000>;

    phy0: ethernet-phy@0 {          /* @N = MDIO adresi */
        reg = <0>;                  /* MDIO adres 0 */
        compatible = "ethernet-phy-id0283.bc30",  /* PHYID ile eşleşme */
                     "ethernet-phy-ieee802.3-c22"; /* Clause 22 fallback */
        interrupt-parent = <&gpio>;
        interrupts = <18 IRQ_TYPE_EDGE_FALLING>;
        /* RGMII gecikme ayarları (DP83867 özel özelliği) */
        ti,rx-internal-delay = <DP83867_RGMIIDCTL_2_00_NS>;
        ti,tx-internal-delay = <DP83867_RGMIIDCTL_2_00_NS>;
        ti,fifo-depth = <DP83867_PHYCR_FIFO_DEPTH_4_B_NIB>;
    };
};

&gmac1 {
    status = "okay";
    phy-mode = "rgmii";
    fixed-link {
        speed    = <1000>;
        full-duplex;
        pause;
        asym-pause;
    };
};

# Bağlantı hızı, duplex, auto-neg durumu
ethtool eth0

# Sürücü bilgisi ve bus-info
ethtool -i eth0

# PHY register'larını oku (clause 22)
ethtool -d eth0

# Belirli MII register oku (BMSR = reg 1)
ethtool --dump-module eth0

# Hız ve duplex zorla (auto-neg bypass)
ethtool -s eth0 speed 100 duplex full autoneg off

# PHY istatistikleri
ethtool --phy-statistics eth0

# EEE (Energy Efficient Ethernet) durumu
ethtool --show-eee eth0

# Bağlantı durumu
mii-tool eth0

# Ayrıntılı çıktı
mii-tool -v eth0

# Auto-neg yeniden başlat
mii-tool -r eth0

# Sistemdeki MDIO bus'ları listele
ls /sys/bus/mdio_bus/devices/

# PHY ID (PHYIDR1:PHYIDR2)
cat /sys/bus/mdio_bus/devices/0000:00/phy_id

# PHY sürücüsü
cat /sys/bus/mdio_bus/devices/0000:00/modalias

# Bağlantı parametreleri
cat /sys/bus/mdio_bus/devices/0000:00/link

# phylink durum makinesi (debugfs)
cat /sys/kernel/debug/phylink/eth0

# Kernel log — phylink durum geçişleri
dmesg | grep -E "phylink|PHY|eth0"

# Dinamik debug etkinleştir
echo "module phylink +p" > /sys/kernel/debug/dynamic_debug/control
echo "module phy_device +p" > /sys/kernel/debug/dynamic_debug/control

# MDIO register dump (mdio-tools paketi)
mdio-tool read 0 BMSR
mdio-tool read 0 PHYIDR1
mdio-tool read 0 PHYIDR2