PHY状态机分析

陈施有

PHY的12种状态

1. enum phy_state {
2.         PHY_DOWN = 0, //关闭网卡
3.         PHY_STARTING, //PHY设备准备好了，PHY driver尚为准备好
4.         PHY_READY,       //PHY设备注册成功
5.         PHY_PENDING,  //PHY芯片挂起
6.         PHY_UP,              //开启网卡
7.         PHY_AN,             //网卡自协商
8.         PHY_RUNNING, //网卡已经插入网线并建立物理连接，该状态可切换到PHY_CHANGELINK
9.         PHY_NOLINK,    //断网，拔掉网线
10.         PHY_FORCING,//自动协商失败，强制处理（读phy状态寄存器，设置速率，设置工作模式）
11.         PHY_CHANGELINK, //LINK检查，当物理连接存在时切换到PHY_RUNING，物理连接不存在时切换到PHY_NOLINK
12.         PHY_HALTED,   //网卡关闭时，PHY挂起
13.         PHY_RESUMING //网卡开启时，PHY恢复
14. };

复制代码

PHY状态机

PHY指PHY芯片，负责数据传送与接收所需要的电与光信号、线路状态、时钟基准、数据编码和电路等,并向数据链路层设备提供标准接口。
MAC指MAC芯片，属于数据链路层，提供寻址机构、数据帧的构建、数据差错检查、传送控制、向网络层提供标准的数据接口等功能。
PHY_DOWN: phy、phy driver、mac都没准备好

• 如果phy driver被集成在内核中，PHY.probe后，phydev状态为PHY_READY。
  
• 如果phy driver被未集成在内核中，PHY.probe后，phydev状态为PHY_STARTING。
  

PHY_READY：phy、phy driver已经就绪，mac未准备好
当MAC层加载时，在PHY.start后，phydev状态切换为PHY_UP。
PHY_STARTING：phy准备就绪，phy driver、mac未准备好

• 当MAC加载时，PHY.start后，phydev状态为PHY_PENDING。
  
• 当phy driver加载时，phydev状态为PHY_READY。
  

PHY_PENDING：phy、mac准备就绪,phy driver未准备好
当phy dirver加载后，phdev状态为PHY_UP
上图中0-->1-->2-->4、0-->2-->4代表phy、phy dirver、mac顺序加载。
0-->1-->3-->4代表phy、mac、phy driver顺序加载。
PHY_UP：phy、phy driver、mac准备就绪
当前状态将启动自动协商，若启动成功则进入PHY_AN，若启动失败则进入PHY_FORCING。
PHY_AN：网卡自协商模式，检测自协商是否完成。
先判断物理链路的状态，如果未LINK则进入PHY_NOLINK，如果LINK则判断自协商是否完成，
自协商完成进入PHY_RUNNING，若自协商超时则重新开启自协商。
PHY_FORCING：强制协商
读link和自协商状态寄存器，如果状态正常则进入PHY_RUNNING模式。
PHY_NOLINK：物理链路未连接
判断物理链路状态，如果LINK，再判断是否支持自协商，若支持待自协商完成后进入PHY_RUNNING模式，
若不支持，直接进入PHY_RUNNING模式。若自协商处于挂起状态，则进入PHY_AN模式。
PHY_RUNNING：正常运行中
获取当前link状态，当link状态发生改变时，进入PHY_CHANGELINK模式。
PHY_CHANGELINK：检查物理链路
物理链路link时，切换到PHY_RUNNING，非LINK时切换到PHY_NOLINK。
PHY_HALTED：网卡关闭phy_stop
挂起phy
PHY_RESUMING: 网卡启用phy_start
恢复phy
phy_state_machine是PHY的状态机函数

1. /**
2. * phy_state_machine - Handle the state machine
3. * @work: work_struct that describes the work to be done
4. */
5. void phy_state_machine(struct work_struct *work)
6. {
7.         struct delayed_work *dwork = to_delayed_work(work);
8.         struct phy_device *phydev =
9.                         container_of(dwork, struct phy_device, state_queue);
10.         bool needs_aneg = false, do_suspend = false;
11.         enum phy_state old_state;
12.         int err = 0;
13.         int old_link;
15.         mutex_lock(&phydev->lock);
17.         old_state = phydev->state;
19.         if (phydev->drv->link_change_notify)
20.                 phydev->drv->link_change_notify(phydev);
22.         switch (phydev->state) {
23.         case PHY_DOWN:
24.         case PHY_STARTING:
25.         case PHY_READY:
26.         case PHY_PENDING:
27.                 break;
28.         case PHY_UP:
29.                 needs_aneg = true;
31.                 phydev->link_timeout = PHY_AN_TIMEOUT;
33.                 break;
34.         case PHY_AN:
35.                 err = phy_read_status(phydev);
36.                 if (err < 0)
37.                         break;
39.                 /* If the link is down, give up on negotiation for now */
40.                 if (!phydev->link) {
41.                         phydev->state = PHY_NOLINK;
42.                         netif_carrier_off(phydev->attached_dev);
43.                         phydev->adjust_link(phydev->attached_dev);
44.                         break;
45.                 }
47.                 /* Check if negotiation is done.  Break if there's an error */
48.                 err = phy_aneg_done(phydev);
49.                 if (err < 0)
50.                         break;
52.                 /* If AN is done, we're running */
53.                 if (err > 0) {
54.                         phydev->state = PHY_RUNNING;
55.                         netif_carrier_on(phydev->attached_dev);
56.                         phydev->adjust_link(phydev->attached_dev);
58.                 } else if (0 == phydev->link_timeout--)
59.                         needs_aneg = true;
60.                 break;
61.         case PHY_NOLINK:
62.                 if (phy_interrupt_is_valid(phydev))
63.                         break;
65.                 err = phy_read_status(phydev);
66.                 if (err)
67.                         break;
69.                 if (phydev->link) {
70.                         if (AUTONEG_ENABLE == phydev->autoneg) {
71.                                 err = phy_aneg_done(phydev);
72.                                 if (err < 0)
73.                                         break;
75.                                 if (!err) {
76.                                         phydev->state = PHY_AN;
77.                                         phydev->link_timeout = PHY_AN_TIMEOUT;
78.                                         break;
79.                                 }
80.                         }
81.                         phydev->state = PHY_RUNNING;
82.                         netif_carrier_on(phydev->attached_dev);
83.                         phydev->adjust_link(phydev->attached_dev);
84.                 }
85.                 break;
86.         case PHY_FORCING:
87.                 err = genphy_update_link(phydev);
88.                 if (err)
89.                         break;
91.                 if (phydev->link) {
92.                         phydev->state = PHY_RUNNING;
93.                         netif_carrier_on(phydev->attached_dev);
94.                 } else {
95.                         if (0 == phydev->link_timeout--)
96.                                 needs_aneg = true;
97.                 }
99.                 phydev->adjust_link(phydev->attached_dev);
100.                 break;
101.         case PHY_RUNNING:
102.                 /* Only register a CHANGE if we are polling or ignoring
103.                  * interrupts and link changed since latest checking.
104.                  */
105.                 if (!phy_interrupt_is_valid(phydev)) {
106.                         old_link = phydev->link;
107.                         err = phy_read_status(phydev);
108.                         if (err)
109.                                 break;
111.                         if (old_link != phydev->link)
112.                                 phydev->state = PHY_CHANGELINK;
113.                 }
114.                 /*
115.                  * Failsafe: check that nobody set phydev->link=0 between two
116.                  * poll cycles, otherwise we won't leave RUNNING state as long
117.                  * as link remains down.
118.                  */
119.                 if (!phydev->link && phydev->state == PHY_RUNNING) {
120.                         phydev->state = PHY_CHANGELINK;
121.                         dev_err(&phydev->dev, "no link in PHY_RUNNING\n");
122.                 }
123.                 break;
124.         case PHY_CHANGELINK:
125.                 err = phy_read_status(phydev);
126.                 if (err)
127.                         break;
129.                 if (phydev->link) {
130.                         phydev->state = PHY_RUNNING;
131.                         netif_carrier_on(phydev->attached_dev);
132.                 } else {
133.                         phydev->state = PHY_NOLINK;
134.                         netif_carrier_off(phydev->attached_dev);
135.                 }
137.                 phydev->adjust_link(phydev->attached_dev);
139.                 if (phy_interrupt_is_valid(phydev))
140.                         err = phy_config_interrupt(phydev,
141.                                                    PHY_INTERRUPT_ENABLED);
142.                 break;
143.         case PHY_HALTED:
144.                 if (phydev->link) {
145.                         phydev->link = 0;
146.                         netif_carrier_off(phydev->attached_dev);
147.                         phydev->adjust_link(phydev->attached_dev);
148.                         do_suspend = true;
149.                 }
150.                 break;
151.         case PHY_RESUMING:
152.                 if (AUTONEG_ENABLE == phydev->autoneg) {
153.                         err = phy_aneg_done(phydev);
154.                         if (err < 0)
155.                                 break;
157.                         /* err > 0 if AN is done.
158.                          * Otherwise, it's 0, and we're  still waiting for AN
159.                          */
160.                         if (err > 0) {
161.                                 err = phy_read_status(phydev);
162.                                 if (err)
163.                                         break;
165.                                 if (phydev->link) {
166.                                         phydev->state = PHY_RUNNING;
167.                                         netif_carrier_on(phydev->attached_dev);
168.                                 } else        {
169.                                         phydev->state = PHY_NOLINK;
170.                                 }
171.                                 phydev->adjust_link(phydev->attached_dev);
172.                         } else {
173.                                 phydev->state = PHY_AN;
174.                                 phydev->link_timeout = PHY_AN_TIMEOUT;
175.                         }
176.                 } else {
177.                         err = phy_read_status(phydev);
178.                         if (err)
179.                                 break;
181.                         if (phydev->link) {
182.                                 phydev->state = PHY_RUNNING;
183.                                 netif_carrier_on(phydev->attached_dev);
184.                         } else        {
185.                                 phydev->state = PHY_NOLINK;
186.                         }
187.                         phydev->adjust_link(phydev->attached_dev);
188.                 }
189.                 break;
190.         }
192.         mutex_unlock(&phydev->lock);
194.         if (needs_aneg)
195.                 err = phy_start_aneg(phydev);
196.         else if (do_suspend)
197.                 phy_suspend(phydev);
199.         if (err < 0)
200.                 phy_error(phydev);
202.         dev_dbg(&phydev->dev, "PHY state change %s -> %s\n",
203.                 phy_state_to_str(old_state), phy_state_to_str(phydev->state));
205.         queue_delayed_work(system_power_efficient_wq, &phydev->state_queue,
206.                            PHY_STATE_TIME * HZ);
207. }

复制代码

来源:https://www.cnblogs.com/forwards/p/17101019.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！