phy自协商逻辑和原理

为了展示PHY驱动的自协商逻辑和原理，我们可以编写一个简单的内核模块示例，模拟PHY设备的自协商过程。这个示例不会实际驱动物理硬件，而是用来演示自协商的流程，包括公告、能力匹配、配置应用等。

以下代码将展示PHY设备在不同的速率和双工模式下进行自协商的基本逻辑：

```c
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/phy.h>
#include <linux/timer.h>
#include <linux/netdevice.h>

// 模拟的PHY设备能力
#define PHY_CAP_10MB_HALF  (1 << 0)
#define PHY_CAP_10MB_FULL  (1 << 1)
#define PHY_CAP_100MB_HALF (1 << 2)
#define PHY_CAP_100MB_FULL (1 << 3)
#define PHY_CAP_1000MB_FULL (1 << 4)

// 定义一个结构体来存储PHY设备的能力
struct phy_device_demo {
    unsigned int capabilities;  // 支持的能力
    unsigned int partner_capabilities; // 对方设备的能力
    unsigned int negotiated_speed; // 协商后的速度
    bool negotiated_duplex; // 协商后的双工模式（0：半双工，1：全双工）
    struct timer_list negotiation_timer; // 自协商定时器
};

// 创建一个模拟的PHY设备
static struct phy_device_demo phy_demo = {
    .capabilities = PHY_CAP_10MB_HALF | PHY_CAP_10MB_FULL | 
                    PHY_CAP_100MB_HALF | PHY_CAP_100MB_FULL |
                    PHY_CAP_1000MB_FULL,
    .partner_capabilities = PHY_CAP_10MB_HALF | PHY_CAP_100MB_FULL,
};

// 自协商函数，模拟设备公告、匹配、选择最佳配置
static void phy_auto_negotiation(struct timer_list *t) {
    struct phy_device_demo *phy = from_timer(phy, t, negotiation_timer);

    printk(KERN_INFO "PHY设备：开始自协商...\n");
    printk(KERN_INFO "本设备能力：0x%x，对方能力：0x%x\n",
           phy->capabilities, phy->partner_capabilities);

    // 进行能力匹配，按优先级排序从高到低匹配
    if ((phy->capabilities & phy->partner_capabilities) & PHY_CAP_1000MB_FULL) {
        phy->negotiated_speed = 1000;
        phy->negotiated_duplex = 1;
    } else if ((phy->capabilities & phy->partner_capabilities) & PHY_CAP_100MB_FULL) {
        phy->negotiated_speed = 100;
        phy->negotiated_duplex = 1;
    } else if ((phy->capabilities & phy->partner_capabilities) & PHY_CAP_100MB_HALF) {
        phy->negotiated_speed = 100;
        phy->negotiated_duplex = 0;
    } else if ((phy->capabilities & phy->partner_capabilities) & PHY_CAP_10MB_FULL) {
        phy->negotiated_speed = 10;
        phy->negotiated_duplex = 1;
    } else if ((phy->capabilities & phy->partner_capabilities) & PHY_CAP_10MB_HALF) {
        phy->negotiated_speed = 10;
        phy->negotiated_duplex = 0;
    } else {
        printk(KERN_ERR "PHY设备：未找到共同的能力，无法协商！\n");
        return;
    }

    printk(KERN_INFO "PHY自协商结果：速度 = %d Mbps，双工模式 = %s\n",
           phy->negotiated_speed,
           phy->negotiated_duplex ? "全双工" : "半双工");
}

// 模块加载函数
static int __init phy_demo_init(void) {
    printk(KERN_INFO "加载PHY自协商示例模块\n");

    // 初始化定时器模拟自协商过程
    timer_setup(&phy_demo.negotiation_timer, phy_auto_negotiation, 0);
    mod_timer(&phy_demo.negotiation_timer, jiffies + msecs_to_jiffies(1000));

    return 0;
}

// 模块卸载函数
static void __exit phy_demo_exit(void) {
    del_timer(&phy_demo.negotiation_timer);
    printk(KERN_INFO "卸载PHY自协商示例模块\n");
}

module_init(phy_demo_init);
module_exit(phy_demo_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("ChatGPT");
MODULE_DESCRIPTION("PHY自协商演示模块");
```

### 代码说明

1. **PHY设备能力定义**：
   - 定义了PHY设备支持的能力，如10Mbps半双工、10Mbps全双工、100Mbps半双工、100Mbps全双工、1000Mbps全双工。
   - 通过`phy_demo`结构体的`capabilities`字段来模拟本设备的能力，`partner_capabilities`字段表示对方设备的能力。

2. **自协商函数`phy_auto_negotiation`**：
   - 通过定时器模拟PHY自协商过程。
   - 按照优先级顺序（从高到低）来选择最佳的链路参数。
   - 最终输出协商结果，包括速度和双工模式。

3. **模块初始化和卸载**：
   - 在模块初始化时设置定时器，使自协商函数在加载模块1秒后运行。
   - 在模块卸载时删除定时器，释放资源。

### 编译和运行

1. 将代码保存到一个`.c`文件中（如`phy_demo.c`），并使用`Makefile`编译生成内核模块。
2. 加载模块：`sudo insmod phy_demo.ko`
3. 查看日志：`dmesg | tail`，可以看到模拟的自协商过程和结果。
4. 卸载模块：`sudo rmmod phy_demo`

### 输出示例

加载模块后，`dmesg`输出可能如下：

```
加载PHY自协商示例模块
PHY设备：开始自协商...
本设备能力：0x1f，对方能力：0x12
PHY自协商结果：速度 = 100 Mbps，双工模式 = 全双工
```

此示例显示了自协商过程的基本原理和步骤。