一文搞懂 Linux 網絡 Phy 驅動
概述
上圖來自 瑞昱半導體 (RealTek) 的 RTL8201F 系列網卡 PHY 芯片手冊。按 OSI 7 層網絡模型劃分，網卡 PHY 芯片 (圖中的 RTL8201F) 位於物理層，對應的軟件層就是本文討論的 PHY 驅動層；而 MAC 位於 數據鏈路層，也是通常軟件上所說的網卡驅動層，它不是本文的重點，不做展開。另外，可通過 MDIO 接口對 PHY 芯片進行配置（如 PHY 芯片寄存器讀寫），而 PHY 和 MAC 通過 MII/RMII 進行數據傳輸。
PHY 芯片通過 MII/GMII/RMII/SGMII/XGMII 等多種媒體獨立接口（介質無關接口）與數據鏈路層的 MAC 芯片相連，並通過 MDIO 接口實現對 PHY 狀態的監控、配置和管理。
PHY 與 MAC 整體的連接框圖：
數據結構
每個 phy 芯片會創建一個 struct phy_device 類型的設備，對應的有 struct phy_driver 類型的驅動，這兩者實際上是掛載在 mdio_bus_type 總線上的，mac 會被註冊成 struct net_device。
phy_device
struct phy_device {
struct phy_driver *drv; // PHY設備驅動
struct mii_bus *bus; // 對應的MII總線
struct device dev; // 設備文件
u32 phy_id; // PHY ID
struct phy_c45_device_ids c45_ids;
bool is_c45;
bool is_internal;
bool has_fixups;
bool suspended;
enum phy_state state; // PHY狀態
u32 dev_flags;
phy_interface_t interface; // PHY接口
int addr; // PHY 總線地址(0~31)
int speed; // 速度
int duplex; // 雙工模式
int pause; // 停止
int asym_pause;
int link;
u32 interrupts; // 中斷使能標誌
u32 supported;
u32 advertising;
u32 lp_advertising;
int autoneg;
int link_timeout;
int irq; // 中斷號
void *priv; // 私有數據
struct work_struct phy_queue; // PHY工作隊列
struct delayed_work state_queue; // PHY延時工作隊列
atomic_t irq_disable;
struct mutex lock;
struct net_device *attached_dev; // 網絡設備
void (*adjust_link)(struct net_device *dev);
};phy_driver
struct phy_driver {
struct mdio_driver_common mdiodrv;
u32 phy_id;
char *name;
u32 phy_id_mask;
u32 features;
u32 flags;
const void *driver_data;
int (*soft_reset)(struct phy_device *phydev);
int (*config_init)(struct phy_device *phydev);
int (*probe)(struct phy_device *phydev);
int (*suspend)(struct phy_device *phydev);
int (*resume)(struct phy_device *phydev);
int (*config_aneg)(struct phy_device *phydev);
int (*aneg_done)(struct phy_device *phydev);
int (*read_status)(struct phy_device *phydev);
int (*ack_interrupt)(struct phy_device *phydev);
int (*config_intr)(struct phy_device *phydev);
int (*did_interrupt)(struct phy_device *phydev);
void (*remove)(struct phy_device *phydev);
int (*match_phy_device)(struct phy_device *phydev);
int (*ts_info)(struct phy_device *phydev, struct ethtool_ts_info *ti);
int (*hwtstamp)(struct phy_device *phydev, struct ifreq *ifr);
bool (*rxtstamp)(struct phy_device *dev, struct sk_buff *skb, int type);
void (*txtstamp)(struct phy_device *dev, struct sk_buff *skb, int type);
int (*set_wol)(struct phy_device *dev, struct ethtool_wolinfo *wol);
void (*get_wol)(struct phy_device *dev, struct ethtool_wolinfo *wol);
void (*link_change_notify)(struct phy_device *dev);
int (*read_mmd)(struct phy_device *dev, int devnum, u16 regnum);
int (*write_mmd)(struct phy_device *dev, int devnum, u16 regnum,
u16 val);
int (*read_page)(struct phy_device *dev);
int (*write_page)(struct phy_device *dev, int page)
int (*module_info)(struct phy_device *dev,
struct ethtool_modinfo *modinfo);
int (*module_eeprom)(struct phy_device *dev,
struct ethtool_eeprom *ee, u8 *data);
int (*get_sset_count)(struct phy_device *dev);
void (*get_strings)(struct phy_device *dev, u8 *data);
void (*get_stats)(struct phy_device *dev,
struct ethtool_stats *stats, u64 *data);
int (*get_tunable)(struct phy_device *dev,
struct ethtool_tunable *tuna, void *data);
int (*set_tunable)(struct phy_device *dev,
struct ethtool_tunable *tuna,
const void *data);
int (*set_loopback)(struct phy_device *dev, bool enable);
ANDROID_KABI_RESERVE(1);
ANDROID_KABI_RESERVE(2);
};mii_bus
struct mii_bus {
const char *name; // 總線名字
char id[MII_BUS_ID_SIZE]; // ID MII_BUS_ID_SIZE=61
void *priv; // 私有數據
int (*read)(struct mii_bus *bus, int phy_id, int regnum); // 讀方式
int (*write)(struct mii_bus *bus, int phy_id, int regnum, u16 val); // 寫方式
int (*reset)(struct mii_bus *bus); // 復位
struct mutex mdio_lock;
struct device *parent; // 父設備
enum {
MDIOBUS_ALLOCATED = 1,
MDIOBUS_REGISTERED,
MDIOBUS_UNREGISTERED,
MDIOBUS_RELEASED,
} state; // 總線狀態
struct device dev; // 設備文件
struct phy_device *phy_map[PHY_MAX_ADDR]; // PHY設備數組
u32 phy_mask;
int *irq; // 中斷
};net_device
struct net_device {
char name[IFNAMSIZ]; /* 用於存放網絡設備的設備名稱 */
char *ifalias; /* 網絡設備的別名 */
int ifindex; /* 網絡設備的接口索引值，獨一無二的網絡設備標識符 */
struct hlist_node name_hlist; /* 這個字段用於構建網絡設備名的哈希散列表，而struct net中的name_hlist就指向每個哈希散列表的鏈表頭 */
struct hlist_node index_hlist; /* 用於構建網絡設備的接口索引值哈希散列表，在struct net中的index_hlist用於指向接口索引值哈希散列表的鏈表頭 */
struct list_head dev_list; /* 用於將每一個網絡設備加入到一個網絡命名空間中的網絡設備雙鏈表中 */
unsigned int flags; /* 網絡設備接口的標識符 */
unsigned int priv_flags; /* 網絡設備接口的標識符，但對用戶空間不可見；*/
unsigned short type; /* 接口硬件類型 */
unsigned int mtu; /* 網絡設備接口的最大傳輸單元 */
unsigned short hard_header_len; /* 硬件接口頭長度 */
unsigned char *dev_addr; /* 網絡設備接口的MAC地址 */
bool uc_promisc; /* 網絡設備接口的單播模式 */
unsigned int promiscuity; /* 網絡設備接口的混雜模式 */
unsigned int allmulti; /* 網絡設備接口的全組播模式 */
struct netdev_hw_addr_list uc; /* 輔助單播MAC地址列表 */
struct netdev_hw_addr_list mc; /* 主mac地址列表 */
struct netdev_hw_addr_list dev_addrs; /* hw設備地址列表 */
unsigned char broadcast[MAX_ADDR_LEN]; /* hw廣播地址 */
struct netdev_rx_queue *_rx; /* 網絡設備接口的數據包接收隊列 */
struct netdev_queue *_tx /* 網絡設備接口的數據包發送隊列 */
unsigned int num_tx_queues; /* TX隊列數 */
unsigned int real_num_tx_queues; /* 當前設備活動的TX隊列數 */
unsigned long tx_queue_len; /* 每個隊列允許的最大幀 */
unsigned long state; /* 網絡設備接口的狀態 */
struct net_device_stats stats; /* 網絡設備接口的統計情況 */
possible_net_t nd_net; /* 用於執行網絡設備所在的命名空間 */
}；phy 設備的註冊
以網卡 Fec 爲例，網卡驅動在初始化 fec_probe() 時遍歷 dts 的定義，創建相應 struct phy_device 類型的設備，主要步驟爲：
-
註冊網絡設備 net_device
-
申請隊列和 DMA
-
申請 MDIO 總線
-
創建並註冊 Phy 設備
fec_probe(struct platform_device *pdev)
-> struct device_node *np = pdev->dev.of_node, *phy_node; // 獲取設備樹節點句柄，並創建一個phy的設備樹節點句柄
-> fec_enet_get_queue_num(pdev, &num_tx_qs, &num_rx_qs); // 從設備樹獲取fsl,num-tx-queues和fsl,num-rx-queues的屬性值
-> ndev = alloc_etherdev_mqs // 申請net_device
-> netdev_priv(ndev) // 獲取私有數據空間首地址
--------------------------------------------------------------------------------------------------------------------------
-> of_parse_phandle(np, "phy-handle", 0) // 從mac的設備樹節點中獲取phy子節點
-> of_get_phy_mode(pdev->dev.of_node) // 從設備樹節點中獲取phy模式，phy-mode = "rmii";
-> fec_reset_phy(pdev); // 復位phy
-> fec_enet_init(ndev) // 申請隊列和DMA，設置MAC地址
-> of_property_read_u32(np, "fsl,wakeup_irq", &irq) // 喚醒中斷
-> fec_enet_mii_init(pdev); // 註冊MDIO總線、註冊phy_device
-> fep->mii_bus = mdiobus_alloc() //申請MDIO總線
-> fep->mii_bus->name = "fec_enet_mii_bus"; // 總線名字
-> fep->mii_bus->read = fec_enet_mdio_read; // 總線的讀函數
-> fep->mii_bus->write = fec_enet_mdio_write; // 總線的寫函數
-> snprintf(fep->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
pdev->name, fep->dev_id + 1); // 總線id
-> of_get_child_by_name(pdev->dev.of_node, "mdio"); // 獲取phy節點句柄
-> of_mdiobus_register // 註冊mii_bus設備，並通過設備樹子節點創建PHY設備 drivers/of/of_mdio.c of_mdiobus_register(struct mii_bus *mdio, struct device_node *np)
-> mdio->phy_mask = ~0; // 屏蔽所有PHY,防止自動探測。相反，設備樹中列出的phy將在總線註冊後填充
-> mdio->dev.of_node = np;
-> mdio->reset_delay_us = DEFAULT_GPIO_RESET_DELAY;
-> mdiobus_register(mdio) // 註冊MDIO總線設備
-> bus->dev.parent = bus->parent;
-> bus->dev.class = &mdio_bus_class; // 總線設備類“/sys/bus/mdio_bus”
/*-----------------------------------------
static struct class mdio_bus_class = {
.name = "mdio_bus",
.dev_release = mdiobus_release,
};
-------------------------------------------*/
-> bus->dev.groups = NULL;
-> dev_set_name(&bus->dev, "%s", bus->id); //設置總線設備的名稱
-> device_register(&bus->dev); // 註冊總線設備
-> if (bus->reset) bus->reset(bus); // 總線復位
---------------------------------------另一條分支解析(可忽略)--------------------------------------------------------
-> phydev = mdiobus_scan(bus, i); // 掃描phy設備
-> phydev = get_phy_device(bus, addr); //獲取創建phy設備
->err = phy_device_register(phydev); //註冊phy設備
--------------------------------------------------------------------------------------------------------------------
-> for_each_available_child_of_node(np, child) { // 遍歷這個平臺設備的子節點併爲每個phy註冊一個phy_device
-> addr = of_mdio_parse_addr(&mdio->dev, child) // 從子節點的"reg"屬性中獲得PHY設備的地址
-> of_property_read_u32(np, "reg", &addr)
-> if (addr < 0) scanphys = true; continue; // 如果未獲得子節點的"reg"屬性,則在後面再啓用掃描可能存在的PHY的,然後註冊
-> of_mdiobus_register_phy(mdio, child, addr) } // 創建並註冊PHY設備
-> is_c45 = of_device_is_compatible(child,"ethernet-phy-ieee802.3-c45") //判斷設備樹中的PHY的屬性是否指定45號條款
-> if (!is_c45 && !of_get_phy_id(child, &phy_id)) //如果設備樹中的PHY的屬性未指定45號條款 且未通過"ethernet-phy-id%4x.%4x"屬性指定PHY的ID
-> phy = phy_device_create(mdio, addr, phy_id, 0, NULL);
-> else phy = get_phy_device(mdio, addr, is_c45); //用這個分支
-> get_phy_id(bus, addr, &phy_id, is_c45, &c45_ids);//通過mdio得到PHY的ID
-> mdiobus_read(bus, addr, MII_PHYSID1)
-> __mdiobus_read(bus, addr, regnum);
-> bus->read(bus, addr, regnum)
-> mdiobus_read(bus, addr, MII_PHYSID2)
-> phy_device_create(bus, addr, phy_id, is_c45, &c45_ids) // 創建PHY設備
-> struct phy_device *dev;
-> dev = kzalloc(sizeof(*dev), GFP_KERNEL);
dev->dev.release = phy_device_release;
dev->speed = 0;
dev->duplex = -1;
dev->pause = 0;
dev->asym_pause = 0;
dev->link = 1;
dev->interface = PHY_INTERFACE_MODE_GMII;
dev->autoneg = AUTONEG_ENABLE; // 默認支持自協商(自動使能)
dev->is_c45 = is_c45;
dev->addr = addr;
dev->phy_id = phy_id;
if (c45_ids)
dev->c45_ids = *c45_ids;
dev->bus = bus;
dev->dev.parent = bus->parent;
dev->dev.bus = &mdio_bus_type; //PHY設備和驅動都會掛在mdio_bus下,匹配時會調用對應的match函數 --
/*----------------------------------------------------------------------------------------------------
struct bus_type mdio_bus_type = {
.name = "mdio_bus", //總線名稱
.match = mdio_bus_match, //用來匹配總線上設備和驅動的函數
.pm = MDIO_BUS_PM_OPS,
.dev_groups = mdio_dev_groups,
};
----------------------------------------------------------------------------------------------------*/
dev->irq = bus->irq != NULL ? bus->irq[addr] : PHY_POLL;
dev_set_name(&dev->dev, PHY_ID_FMT, bus->id, addr);
dev->state = PHY_DOWN; //指示PHY設備和驅動程序尚未準備就緒,在PHY驅動的probe函數中會更改爲READY
-> INIT_DELAYED_WORK(&dev->state_queue, phy_state_machine); //PHY的狀態機(核心WORK)後續解析
-> INIT_WORK(&dev->phy_queue, phy_change); // 由phy_interrupt / timer調度以處理PHY狀態的更改
-> request_module(MDIO_MODULE_PREFIX MDIO_ID_FMT, MDIO_ID_ARGS(phy_id)); // 加載內核模塊
-> device_initialize(&dev->dev); //設備模型中的一些設備,主要是kset、kobject、ktype的設置
-> irq_of_parse_and_map(child, 0); //將中斷解析並映射到linux virq空間(
-> of_node_get(child); //將OF節點與設備結構相關聯
-> phy->dev.of_node = child;
-> phy_device_register(phy) // 註冊phy設備
-> if (phydev->bus->phy_map[phydev->addr]) //判斷PHY是否已經註冊了
-> phydev->bus->phy_map[phydev->addr] = phydev; //添加PHY到總線的phy_map裏
-> phy_scan_fixups(phydev); //執行匹配的fixups
-> device_add(&phydev->dev); // 註冊到linux設備模型框架中
-> if (!scanphys) return 0; // 如果從子節點的"reg"屬性中獲得PHY設備的地址,scanphys=false,這裏就直接返回了,因爲不需要再掃描了
------------一般來說只要設備樹種指定了PHY設備的"reg"屬性，後面的流程可以自動忽略 ------------
-> register_netdev(ndev) // 向內核註冊net_devicephy 驅動的註冊
genphy_driver 通用驅動
內核中有 genphy_driver 通用驅動，以及專有驅動（這裏以 NXP TJA 驅動爲例），分別如下：
static struct phy_driver genphy_driver = {
.phy_id = 0xffffffff,
.phy_id_mask = 0xffffffff,
.name = "Generic PHY",
.get_features = genphy_read_abilities,
.suspend = genphy_suspend,
.resume = genphy_resume,
.set_loopback = genphy_loopback,
};static struct phy_driver tja11xx_driver[] = {
{
PHY_ID_MATCH_MODEL(PHY_ID_TJA1100),
.name = "NXP TJA1100",
.features = PHY_BASIC_T1_FEATURES,
.probe = tja11xx_probe,
.soft_reset = tja11xx_soft_reset,
.config_aneg = tja11xx_config_aneg,
.config_init = tja11xx_config_init,
.read_status = tja11xx_read_status,
.get_sqi = tja11xx_get_sqi,
.get_sqi_max = tja11xx_get_sqi_max,
.suspend = genphy_suspend,
.resume = genphy_resume,
.set_loopback = genphy_loopback,
/* Statistics */
.get_sset_count = tja11xx_get_sset_count,
.get_strings = tja11xx_get_strings,
.get_stats = tja11xx_get_stats,
}
};
module_phy_driver(tja11xx_driver);genphy_driver 的 struct phy_driver 的註冊過程如下:
phy_init
phy_driver_register()
driver_register(&new_driver->mdiodrv.driver)
bus_add_driver(drv)
driver_attach(drv)
bus_for_each_dev(drv->bus, NULL, drv, __driver_attach)
while ((dev = next_device(&i)) && !error)
/* 循環到註冊的 PHY 設備時 */
fn(dev, data) = __driver_attach()
/* 匹配設備和驅動 */
driver_match_device(drv, dev)
mdio_bus_match(dev, drv)
phy_bus_match(dev, drv)
/* 按 phy_id & phy_id_mask 匹配 */
return (phydrv->phy_id & phydrv->phy_id_mask) == (phydev->phy_id & phydrv->phy_id_mask);
/* 匹配到設備和驅動，加載驅動 */
driver_probe_device(drv, dev)
really_probe(dev, drv)
dev->driver = drv; /* 綁定設備的驅動 */
drv->probe(dev) = phy_probe其中一個關鍵點是 mdio driver 的 probe 函數是一個通用函數 phy_probe：
static int phy_probe(struct device *dev)
{
struct phy_device *phydev = to_phy_device(dev); // 獲取PHY設備
struct device_driver *drv = phydev->mdio.dev.driver;
struct phy_driver *phydrv = to_phy_driver(drv); // 獲取PHY驅動
int err = 0;
phydev->drv = phydrv; /* 綁定 phy_device 和 phy_driver */
/* PHY 中斷模式最終配置 */
if (!phy_drv_supports_irq(phydrv) && phy_interrupt_is_valid(phydev)) // 設置中斷方式
phydev->irq = PHY_POLL;
if (phydrv->flags & PHY_IS_INTERNAL)
phydev->is_internal = true;
/* Deassert the reset signal */
phy_device_reset(phydev, 0);
if (phydev->drv->probe) { // 判斷驅動有probe方式
err = phydev->drv->probe(phydev); /* PHY 驅動的 probe */
if (err)
goto out;
}
......
if (phydrv->features) {
linkmode_copy(phydev->supported, phydrv->features);
}
else if (phydrv->get_features)
err = phydrv->get_features(phydev);
else if (phydev->is_c45)
err = genphy_c45_pma_read_abilities(phydev);
else
err = genphy_read_abilities(phydev); //讀取狀態寄存器來確定 phy 芯片的能力
if (err)
goto out;
if (!linkmode_test_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
phydev->supported))
phydev->autoneg = 0;
if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
phydev->supported))
phydev->is_gigabit_capable = 1;
if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
phydev->supported))
phydev->is_gigabit_capable = 1;
/* PHY 功能特性配置 */
of_set_phy_supported(phydev);
phy_advertise_supported(phydev);
......
of_set_phy_eee_broken(phydev);
......
if (!test_bit(ETHTOOL_LINK_MODE_Pause_BIT, phydev->supported) &&
!test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, phydev->supported)) {
linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT,
phydev->supported);
linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
phydev->supported);
}
/* Set the state to READY by default */
phydev->state = PHY_READY; /* 標記 PHY 設備已經就緒 */
out:
/* Re-assert the reset signal on error */
if (err)
phy_device_reset(phydev, 1);
return err;
}其中通用 phy 驅動會調用函數 genphy_read_abilities 來讀取狀態寄存器來確定 phy 芯片的能力：
genphy_read_abilities()
`-| {
| val = phy_read(phydev, MII_BMSR); // 讀取 mdio 0x01 寄存器來確定 phy 的 10/100M 能力
| linkmode_mod_bit(ETHTOOL_LINK_MODE_Autoneg_BIT, phydev->supported, val & BMSR_ANEGCAPABLE);
| linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, phydev->supported, val & BMSR_100FULL);
| linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, phydev->supported, val & BMSR_100HALF);
| linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, phydev->supported, val & BMSR_10FULL);
| linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, phydev->supported, val & BMSR_10HALF);
| if (val & BMSR_ESTATEN) {
| val = phy_read(phydev, MII_ESTATUS); // 讀取 mdio 0x0f 寄存器來確定 phy 的 1000M 能力
| linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, phydev->supported, val & ESTATUS_1000_TFULL);
| linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT, phydev->supported, val & ESTATUS_1000_THALF);
| linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseX_Full_BIT, phydev->supported, val & ESTATUS_1000_XFULL);
| }
| }NXP TJA 專有驅動
NXP TJA 驅動的 struct phy_driver 的註冊過程如下:
#define phy_module_driver(__phy_drivers, __count) \
static int __init phy_module_init(void) \
{ \
return phy_drivers_register(__phy_drivers, __count, THIS_MODULE); \
} \
module_init(phy_module_init); \
static void __exit phy_module_exit(void) \
{ \
phy_drivers_unregister(__phy_drivers, __count); \
} \
module_exit(phy_module_exit)
#define module_phy_driver(__phy_drivers) \
phy_module_driver(__phy_drivers, ARRAY_SIZE(__phy_drivers))int phy_drivers_register(struct phy_driver *new_driver, int n,
struct module *owner)
{
int i, ret = 0;
for (i = 0; i < n; i++) {
ret = phy_driver_register(new_driver + i, owner); // 註冊數組中所有的phy驅動
if (ret) {
while (i-- > 0)
phy_driver_unregister(new_driver + i);
break;
}
}
return ret;
}
EXPORT_SYMBOL(phy_drivers_register);根據上面的分析，由於存在 phydev->drv->probe，所以會調用其註冊的函數 tja11xx_probe。
網卡 fec 和 Phy 的協作
在 linux 內核中，以太網 mac 會被註冊成 struct net_device，phy 芯片會被註冊成 struct phy_device。 phy_device 的狀態怎麼傳遞給 net_device，讓其在 link 狀態變化時做出對應的配置改變，這個任務就落在上述的 struct phylink 中介身上。
下面就以 fec 網口驅動爲例，展示一下網卡 fec 和 phy 的協作過程。整個 phy 驅動的主要調用流程如下圖所示：
一個 phy 驅動的原理其實是非常簡單的，一般流程如下：
-
用輪詢 / 中斷的方式通過 mdio 總線讀取 phy 芯片的狀態。
-
在 phy link 狀態變化的情況下，正確配置 mac 的狀態。（例如：根據 phy 自協商的速率 10/100/1000M 把 mac 配置成對應速率）
phy 芯片狀態在 phy 設備註冊的時候已經體現，這裏詳細講下如何在 phy link 狀態變化的情況下，正確配置 mac 的狀態。
void phy_state_machine(struct work_struct *work)
{
old_state = phydev->state;
/* (1) 狀態機主體 */
switch (phydev->state) {
/* (1.1) 在 PHY_DOWN/PHY_READY 狀態下不動作 */
case PHY_DOWN:
case PHY_READY:
break;
/* (1.2) 在 PHY_UP 狀態下，表明網口被 up 起來，需要啓動自協商並且查詢自協商後的 link 狀態
如果自協商結果是 link up，進入 PHY_RUNNING 狀態
如果自協商結果是 link down，進入 PHY_NOLINK 狀態
*/
case PHY_UP:
needs_aneg = true;
break;
/* (1.3) 在運行的過程中定時輪詢 link 狀態
如果 link up，進入 PHY_RUNNING 狀態
如果 link down，進入 PHY_NOLINK 狀態
*/
case PHY_NOLINK:
case PHY_RUNNING:
err = phy_check_link_status(phydev);
break;
}
/* (2) 如果需要，啓動自協商配置 */
if (needs_aneg)
err = phy_start_aneg(phydev);
/* (3) 如果 phy link 狀態有變化，通知給對應網口 netdev */
if (old_state != phydev->state) {
phydev_dbg(phydev, "PHY state change %s -> %s\n",
phy_state_to_str(old_state),
phy_state_to_str(phydev->state));
if (phydev->drv && phydev->drv->link_change_notify)
phydev->drv->link_change_notify(phydev);
}
/* (4) 重新啓動 work，週期爲 1s */
if (phy_polling_mode(phydev) && phy_is_started(phydev))
phy_queue_state_machine(phydev, PHY_STATE_TIME);
}自協商配置
具體啓動 phy 自協商的代碼流程如下：
phy_state_machine()
`-| phy_start_aneg()
`-| phy_config_aneg()
`-| genphy_config_aneg()
`-| __genphy_config_aneg()
`-| genphy_setup_master_slave() // (1) 如果是千兆網口，配置其 master/slave
`-| {
| phy_modify_changed(phydev, MII_CTRL1000, // 配置 mdio 0x09 寄存器
| (CTL1000_ENABLE_MASTER | CTL1000_AS_MASTER | CTL1000_PREFER_MASTER), ctl);
| }
| genphy_config_advert() // (2) 設置本端的 advert 能力
`-| {
| linkmode_and(phydev->advertising, phydev->advertising, phydev->supported);
| adv = linkmode_adv_to_mii_adv_t(phydev->advertising);
| phy_modify_changed(phydev, MII_ADVERTISE, // 10M/100M 能力配置到 mdio 0x04 寄存器
| ADVERTISE_ALL | ADVERTISE_100BASE4 |
| ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM, adv);
| if (!(bmsr & BMSR_ESTATEN)) return changed;
| adv = linkmode_adv_to_mii_ctrl1000_t(phydev->advertising);
| phy_modify_changed(phydev, MII_CTRL1000, // 1000M 能力配置到 mdio 0x09 寄存器
| ADVERTISE_1000FULL | ADVERTISE_1000HALF, adv);
| }
| genphy_check_and_restart_aneg()
`-| genphy_restart_aneg() // (3) 啓動 phy 自協商
`-| {
| phy_modify(phydev, MII_BMCR, BMCR_ISOLATE, // 配置 mdio 0x00 寄存器
| BMCR_ANENABLE | BMCR_ANRESTART);
| }link 狀態讀取
phy link 狀態讀取的代碼流程如下：
phy_state_machine()
`-| phy_check_link_status()
`-| phy_read_status() // (1) 讀取 link 狀態
`-| genphy_read_status()
`-| {
| genphy_update_link(phydev); // (1.1) 更新 link 狀態
| if (phydev->autoneg == AUTONEG_ENABLE && old_link && phydev->link) return 0;
| genphy_read_master_slave(phydev); // (1.2) 如果是千兆網口，更新本端和對端的 master/slave
| genphy_read_lpa(phydev); // (1.3) 更新對端(link partner) 聲明的能力
| if (phydev->autoneg == AUTONEG_ENABLE && phydev->autoneg_complete) {
| phy_resolve_aneg_linkmode(phydev); // (1.4.1) 自協商模式，解析 link 結果
| } else if (phydev->autoneg == AUTONEG_DISABLE) {
| genphy_read_status_fixed(phydev); // (1.4.2) 固定模式，解析 link 結果
| }
| }
| if (phydev->link && phydev->state != PHY_RUNNING) { // (2) link 狀態 change 事件：變成 link up
| phydev->state = PHY_RUNNING;
| phy_link_up(phydev); // link up 事件，通知給 phylink
| } else if (!phydev->link && phydev->state != PHY_NOLINK) { // (3) link 狀態 change 事件：變成 link down
| phydev->state = PHY_NOLINK;
| phy_link_down(phydev); // link down 事件，通知給 phylink
| }link 狀態通知
phy 的 link 狀態變化怎麼通知給 netdev，並且讓 mac 做出相應的配置改變，這個是通過一箇中介 phylink 來實現的。
phy_link_up()/phy_link_down()
`-| phydev->phy_link_change(phydev, true/false);
`-| phylink_phy_change()
`-| {
| pl->phy_state.speed = phydev->speed; // (1) 把 `phy_device` 狀態更新給 `phylink`
| pl->phy_state.duplex = phydev->duplex;
| pl->phy_state.interface = phydev->interface;
| pl->phy_state.link = up;
| phylink_run_resolve(pl); // (2) 通知 `phylink` 的輪詢任務啓動
| }本文由 Readfog 進行 AMP 轉碼，版權歸原作者所有。
來源：https://mp.weixin.qq.com/s/YhAAwvn5CwRdiRt4MwSVqA