＜kernel＞kernel 6.4 USB-之-port_event()分析
kernel 6.4 USB系列文章如下：
＜kernel＞kernel 6.4 USB-之-hub_event()分析
＜kernel＞kernel 6.4 USB-之-port_event()分析
＜kernel＞kernel 6.4 USB-之-hub_port_connect_change()分析
＜kernel＞kernel 6.4 USB-之-hub_port_connect()分析
＜kernel＞kernel 6.4 USB-之-hub_port_init()分析
＜kernel＞kernel 6.4 USB-之-usb_new_device()分析
本文是基于linux kernel 6.4版本内核分析；源码下载路径：linux kernel
一、前言
在前一篇文章分析了hub_event()函数，之后hub_event()函数会进一步调用 port_event函数；
这个函数port_event的主要作用是处理USB集线器（Hub）上某个特定端口的事件。
具体来看，代码的主要功能如下：
首先，它会检查端口的变化位（change bits）。如果端口的连接状态（connection）或使能状态（enable）发生变化，它会清除相应的端口特性（port feature）。如果端口被禁用并且没有连接变化，它会尝试重新启用端口并将连接更改标志设置为1。
然后，它会检查是否发生了过流（overcurrent）变化。如果过流变化发生，它会清除过流特性，并尝试打开集线器的电源。如果存在过流条件，它会打印一条错误信息。
接着，它会检查端口是否发生了复位（reset）变化。如果复位变化发生，它会清除复位特性。
然后，它会检查端口是否需要进行热复位（warm reset）。如果需要，它会进行一系列的操作来进行热复位，包括尝试复位端口、禁用端口、或者复位设备。
最后，如果连接状态发生变化，它会调用hub_port_connect_change函数来处理连接状态的变化。
所以，这个函数的主要作用是处理USB集线器上某个特定端口的事件，包括连接变化、使能变化、过流变化、复位变化等，以及对这些变化进行相应的处理。
二、port_event()函数
port_event()函数内容如下：
路径：drivers\usb\core\hub.c
static void port_event(struct usb_hub *hub, int port1)
__must_hold(&port_dev->status_lock)
{
int connect_change;
struct usb_port *port_dev = hub->ports[port1 - 1];
struct usb_device *udev = port_dev->child;
struct usb_device *hdev = hub->hdev;
u16 portstatus, portchange;
int i = 0;
connect_change = test_bit(port1, hub->change_bits);
clear_bit(port1, hub->event_bits);
clear_bit(port1, hub->wakeup_bits);
if (usb_hub_port_status(hub, port1, &portstatus, &portchange) < 0)
return;
if (portchange & USB_PORT_STAT_C_CONNECTION) {
usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_CONNECTION);
connect_change = 1;
}
if (portchange & USB_PORT_STAT_C_ENABLE) {
if (!connect_change)
dev_dbg(&port_dev->dev, "enable change, status %08x\n",
portstatus);
usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_ENABLE);
/*
* EM interference sometimes causes badly shielded USB devices
* to be shutdown by the hub, this hack enables them again.
* Works at least with mouse driver.
*/
if (!(portstatus & USB_PORT_STAT_ENABLE)
&& !connect_change && udev) {
dev_err(&port_dev->dev, "disabled by hub (EMI?), re-enabling...\n");
connect_change = 1;
}
}
if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
u16 status = 0, unused;
port_dev->over_current_count++;
port_over_current_notify(port_dev);
dev_dbg(&port_dev->dev, "over-current change #%u\n",
port_dev->over_current_count);
usb_clear_port_feature(hdev, port1,
USB_PORT_FEAT_C_OVER_CURRENT);
msleep(100); /* Cool down */
hub_power_on(hub, true);
usb_hub_port_status(hub, port1, &status, &unused);
if (status & USB_PORT_STAT_OVERCURRENT)
dev_err(&port_dev->dev, "over-current condition\n");
}
if (portchange & USB_PORT_STAT_C_RESET) {
dev_dbg(&port_dev->dev, "reset change\n");
usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_RESET);
}
if ((portchange & USB_PORT_STAT_C_BH_RESET)
&& hub_is_superspeed(hdev)) {
dev_dbg(&port_dev->dev, "warm reset change\n");
usb_clear_port_feature(hdev, port1,
USB_PORT_FEAT_C_BH_PORT_RESET);
}
if (portchange & USB_PORT_STAT_C_LINK_STATE) {
dev_dbg(&port_dev->dev, "link state change\n");
usb_clear_port_feature(hdev, port1,
USB_PORT_FEAT_C_PORT_LINK_STATE);
}
if (portchange & USB_PORT_STAT_C_CONFIG_ERROR) {
dev_warn(&port_dev->dev, "config error\n");
usb_clear_port_feature(hdev, port1,
USB_PORT_FEAT_C_PORT_CONFIG_ERROR);
}
/* skip port actions that require the port to be powered on */
if (!pm_runtime_active(&port_dev->dev))
return;
/* skip port actions if ignore_event and early_stop are true */
if (port_dev->ignore_event && port_dev->early_stop)
return;
if (hub_handle_remote_wakeup(hub, port1, portstatus, portchange))
connect_change = 1;
/*
* Avoid trying to recover a USB3 SS.Inactive port with a warm reset if
* the device was disconnected. A 12ms disconnect detect timer in
* SS.Inactive state transitions the port to RxDetect automatically.
* SS.Inactive link error state is common during device disconnect.
*/
while (hub_port_warm_reset_required(hub, port1, portstatus)) {
if ((i++ < DETECT_DISCONNECT_TRIES) && udev) {
u16 unused;
msleep(20);
usb_hub_port_status(hub, port1, &portstatus, &unused);
dev_dbg(&port_dev->dev, "Wait for inactive link disconnect detect\n");
continue;
} else if (!udev || !(portstatus & USB_PORT_STAT_CONNECTION)
|| udev->state == USB_STATE_NOTATTACHED) {
dev_dbg(&port_dev->dev, "do warm reset, port only\n");
if (hub_port_reset(hub, port1, NULL,
HUB_BH_RESET_TIME, true) < 0)
hub_port_disable(hub, port1, 1);
} else {
dev_dbg(&port_dev->dev, "do warm reset, full device\n");
usb_unlock_port(port_dev);
usb_lock_device(udev);
usb_reset_device(udev);
usb_unlock_device(udev);
usb_lock_port(port_dev);
connect_change = 0;
}
break;
}
if (connect_change)
hub_port_connect_change(hub, port1, portstatus, portchange);
}
下面就对port_event()函数内容详细分析：
2.1 第6行
第6行：从集线器的ports数组中获取第port1个端口的struct usb_port结构体的指针，并将这个指针赋值给port_dev变量。这里的port1是端口的编号，编号从1开始，所以在数组中的索引需要减1。struct usb_port结构体代表了USB集线器上的一个端口，它包含了端口的状态、端口上连接的设备等信息。通过获取struct usb_port结构体的指针，我们可以方便地操作和管理集线器上的端口。
第7行：从port_dev结构体的child成员中获取连接在这个端口上的USB设备的struct usb_device结构体的指针，并将这个指针赋值给udev变量。struct usb_device结构体代表了一个USB设备，它包含了设备的状态、设备的配置等信息。通过获取struct usb_device结构体的指针，我们可以方便地操作和管理USB设备。
2.2 第12-14行:检查USB集线器（Hub）上的特定端口是否发生了连接变化
第12-14行：主要作用是检查USB集线器（Hub）上的特定端口是否发生了连接变化，并清除该端口的事件位和唤醒位。
具体来看，代码的作用如下：
(1)connect_change = test_bit(port1, hub->change_bits);：这行代码检查集线器的变化位中第port1个位是否被设置。如果被设置，那么表示该端口发生了连接变化。这个结果被赋值给connect_change变量。
(2)clear_bit(port1, hub->event_bits);：这行代码清除集线器的事件位中第port1个位。这通常表示已经处理了该端口的事件。
(3)clear_bit(port1, hub->wakeup_bits);：这行代码清除集线器的唤醒位中第port1个位。这通常表示已经处理了该端口的唤醒事件。
所以，这段代码的主要作用是检查USB集线器上的特定端口是否发生了连接变化，并清除该端口的事件位和唤醒位。
2.3 第16-17行:获取USB集线器（Hub）上特定端口的状态和状态变化
第16-17行：主要作用是获取USB集线器（Hub）上特定端口的状态和状态变化。
(1)if (usb_hub_port_status(hub, port1, &portstatus, &portchange) < 0) {…}：这个if语句调用usb_hub_port_status函数来获取集线器上第port1个端口的状态和状态变化。portstatus和portchange是输出参数，用于保存端口的状态和状态变化。如果usb_hub_port_status函数返回值小于0，表示获取状态失败，那么就直接返回，不进行后续的操作。
(2)usb_hub_port_status函数通常用于读取集线器上的端口状态寄存器，获取端口的当前状态和状态变化。端口的状态包括连接状态、使能状态、复位状态等；状态变化包括连接变化、使能变化、复位变化等。
所以，这段代码的主要作用是获取USB集线器上特定端口的状态和状态变化，如果获取状态失败，那么就直接返回，不进行后续的操作。
2.3.1 usb_hub_port_status()函数
usb_hub_port_status()函数内容如下：
static int hub_ext_port_status(struct usb_hub *hub, int port1, int type,
u16 *status, u16 *change, u32 *ext_status)
{
int ret;
int len = 4;
if (type != HUB_PORT_STATUS)
len = 8;
mutex_lock(&hub->status_mutex);
ret = get_port_status(hub->hdev, port1, &hub->status->port, type, len);
if (ret < len) {
if (ret != -ENODEV)
dev_err(hub->intfdev,
"%s failed (err = %d)\n", __func__, ret);
if (ret >= 0)
ret = -EIO;
} else {
*status = le16_to_cpu(hub->status->port.wPortStatus);
*change = le16_to_cpu(hub->status->port.wPortChange);
if (type != HUB_PORT_STATUS && ext_status)
*ext_status = le32_to_cpu(
hub->status->port.dwExtPortStatus);
ret = 0;
}
mutex_unlock(&hub->status_mutex);
return ret;
}
int usb_hub_port_status(struct usb_hub *hub, int port1,
u16 *status, u16 *change)
{
return hub_ext_port_status(hub, port1, HUB_PORT_STATUS,
status, change, NULL);
}
2.4 第19-22行:检查USB集线器（Hub）上特定端口是否发生了连接变化
第19-22行：主要作用是检查USB集线器（Hub）上特定端口是否发生了连接变化，并清除连接变化标志。
具体来看，代码的作用如下：
(1) if (portchange & USB_PORT_STAT_C_CONNECTION) {…}：这个if语句检查portchange中的连接变化位是否被设置。USB_PORT_STAT_C_CONNECTION是一个位掩码，用于在portchange中选出连接变化位。如果连接变化位被设置，那么表示该端口的连接状态发生了变化，就执行后面的代码块。
(2) usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_CONNECTION);：这行代码清除集线器上第port1个端口的连接变化特性。这通常表示已经处理了该端口的连接变化。
2.4.1 usb_clear_port_feature（）
/* USB 2.0规范第11.24.2.2节 */
int usb_clear_port_feature(struct usb_device *hdev, int port1, int feature)
{
return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),
USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port1,
NULL, 0, 1000);
}
(3) connect_change = 1;：这行代码将connect_change变量设置为1，表示该端口的连接状态发生了变化。
所以，这段代码的主要作用是检查USB集线器上特定端口是否发生了连接变化，并清除连接变化标志。
2.5 第24-40行:处理USB端口的状态变化
第24-40行：主要处理USB端口的状态变化，特别是当USB端口的使能状态发生变化时的情况。
(1) 首先，通过检查portchange & USB_PORT_STAT_C_ENABLE来判断USB端口的使能状态是否发生变化。如果变化了，那么进入该if语句块。
(2) 然后，如果connect_change为假（表示没有连接变化），则打印一条调试信息，显示当前端口的状态。
(3) 接着，调用usb_clear_port_feature函数来清除端口的使能状态变化特性。
在注释中提到，由于电磁干扰，一些屏蔽不良的USB设备可能会被集线器关闭。因此，这段代码的下一部分就是处理这种情况的。如果端口没有被使能，并且没有连接变化，且udev不为空（表示有设备连接），那么打印一条错误信息，并将connect_change设置为1，表示需要重新使能设备。
2.6 第42-56行:处理USB端口的过流状态
第42-56行：主要处理USB端口的过流（over-current）状态变化。
(1) 首先，通过检查portchange & USB_PORT_STAT_C_OVERCURRENT来判断USB端口的过流状态是否发生变化。如果变化了，那么进入该if语句块。
(2) 然后，port_dev->over_current_count++用于累计过流次数。
(3) port_over_current_notify(port_dev)函数用来通知相关设备或系统USB端口过流。
2.6.1 port_over_current_notify(port_dev)函数
/* Handle notifying userspace about hub over-current events */
static void port_over_current_notify(struct usb_port *port_dev)
{
char *envp[3] = { NULL, NULL, NULL };
struct device *hub_dev;
char *port_dev_path;
sysfs_notify(&port_dev->dev.kobj, NULL, "over_current_count");
hub_dev = port_dev->dev.parent;
if (!hub_dev)
return;
port_dev_path = kobject_get_path(&port_dev->dev.kobj, GFP_KERNEL);
if (!port_dev_path)
return;
envp[0] = kasprintf(GFP_KERNEL, "OVER_CURRENT_PORT=%s", port_dev_path);
if (!envp[0])
goto exit;
envp[1] = kasprintf(GFP_KERNEL, "OVER_CURRENT_COUNT=%u",
port_dev->over_current_count);
if (!envp[1])
goto exit;
kobject_uevent_env(&hub_dev->kobj, KOBJ_CHANGE, envp);
exit:
kfree(envp[1]);
kfree(envp[0]);
kfree(port_dev_path);
}
首先，sysfs_notify(&port_dev->dev.kobj, NULL, "over_current_count")用于通知用户空间，USB端口的过流计数已经发生变化。
然后，获取USB端口所在的集线器设备。如果集线器设备不存在，则直接返回。
接着，获取USB端口设备在sysfs文件系统中的路径。如果获取失败，则直接返回。
然后，构造两个环境变量，一个是表示过流的USB端口的路径，一个是表示过流次数。这两个环境变量将会被发送到用户空间。
kobject_uevent_env(&hub_dev->kobj, KOBJ_CHANGE, envp)用于发送一个kobject事件，通知用户空间USB端口过流。
最后，释放之前分配的内存。
总结起来，这段代码的主要作用就是当USB端口过流时，通知用户空间进行相应的处理。
(4) 接着，打印一条调试信息，显示当前过流变化的次数。
(5) usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_OVER_CURRENT)函数用来清除端口的过流状态变化特性。
(6) msleep(100)函数让当前线程暂停100毫秒，这是为了让USB端口"冷却"下来。
(7) hub_power_on(hub, true)函数用来打开集线器的电源。
2.6.2 hub_power_on(hub, true)函数
static void hub_power_on(struct usb_hub *hub, bool do_delay)
{
int port1;
/*启用每个端口的电源。一些集线器的描述符中保留了LPSM（>2）值，
即使它们是USB 2.0集线器。有些集线器不实现端口电源切换，
而只是模拟它。在所有情况下，除非我们将这些消息发送到集线器，
否则端口都不会工作*/
if (hub_is_port_power_switchable(hub))
dev_dbg(hub->intfdev, "enabling power on all ports\n");
else
dev_dbg(hub->intfdev, "trying to enable port power on "
"non-switchable hub\n");
for (port1 = 1; port1 <= hub->hdev->maxchild; port1++)
if (test_bit(port1, hub->power_bits))
set_port_feature(hub->hdev, port1, USB_PORT_FEAT_POWER);
else
usb_clear_port_feature(hub->hdev, port1,
USB_PORT_FEAT_POWER);
if (do_delay)
msleep(hub_power_on_good_delay(hub));
}
首先，通过hub_is_port_power_switchable(hub)函数判断集线器的端口是否支持电源切换。如果支持，就打印一条调试信息；如果不支持，也打印一条调试信息，但是信息内容不同。
然后，遍历集线器的所有端口。对于每个端口，如果power_bits中对应的位被设置，那么就调用set_port_feature函数打开端口的电源；否则，调用usb_clear_port_feature函数关闭端口的电源。
最后，如果do_delay参数为真，那么就调用msleep函数暂停一段时间。暂停的时间由hub_power_on_good_delay(hub)函数计算得出。
总的来说，这段代码的作用就是打开USB集线器的所有端口的电源。如果集线器的端口不支持电源切换，那么尝试打开电源可能会失败，但是这段代码仍然会尝试打开电源。
(8) usb_hub_port_status(hub, port1, &status, &unused)函数用来获取端口的状态。
最后，如果端口仍然处于过流状态，那么打印一条错误信息。整体就是判断端口过流，通知系统，并清理端口状态重启端口的供电，然后重新获取状态，仍然过流则输出错误log。
2.6.3 usb_hub_port_status(hub, port1, &status, &unused)函数
int usb_hub_port_status(struct usb_hub *hub, int port1,u16 *status, u16 *change)
-->>hub_ext_port_status(hub, port1, HUB_PORT_STATUS,status, change, NULL);
------->>get_port_status(hub->hdev, port1, &hub->status->port, type, len);
/*
*USB 2.0规范第11.24.2.7节
*USB 3.1考虑使用wValue和wLength字段，规范第10.16.2.6节
*/
static int get_port_status(struct usb_device *hdev, int port1,
void *data, u16 value, u16 length)
{
int i, status = -ETIMEDOUT;
for (i = 0; i < USB_STS_RETRIES &&
(status == -ETIMEDOUT || status == -EPIPE); i++) {
status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, value,
port1, data, length, USB_STS_TIMEOUT);
}
return status;
}
//就是从设备中获取状态信息。
2.7 第58-61行:处理USB端口复位状态
第58-61行：作用是处理USB端口复位状态的变化。
首先，通过检查portchange & USB_PORT_STAT_C_RESET来判断USB端口的复位状态是否发生变化。如果变化了，那么进入该if语句块。
然后，打印一条调试信息，显示"reset change"。
最后，调用usb_clear_port_feature函数来清除端口的复位状态变化特性。
总的来说，这段代码的作用就是当USB端口的复位状态发生变化时，清除该状态变化，并打印一条调试信息。
2.8 第62-67行:处理超高速（superspeed）USB端口的热复位
第62-67行：主要作用是处理超高速（superspeed）USB端口的热复位（warm reset）状态变化。
(1) 首先，通过portchange & USB_PORT_STAT_C_BH_RESET判断USB端口的热复位状态是否发生变化，并通过hub_is_superspeed(hdev)判断该USB设备是否支持超高速模式。如果这两个条件都满足，那么进入if语句块。
static inline int hub_is_superspeed(struct usb_device *hdev)
{
return hdev->descriptor.bDeviceProtocol == USB_HUB_PR_SS;
}
(2) 然后，打印一条调试信息，显示"warm reset change"。
(3) 最后，调用usb_clear_port_feature函数来清除端口的热复位状态变化特性。
总的来说，这段代码的作用就是当支持超高速模式的USB端口的热复位状态发生变化时，清除该状态变化，并打印一条调试信息。。
2.9 第68-72行: 处理USB端口链路状态（Link State）的变化
第68-72行：主要作用是处理USB端口链路状态（Link State）的变化。
首先，通过portchange & USB_PORT_STAT_C_LINK_STATE判断USB端口的链路状态是否发生变化。如果发生变化，那么进入if语句块。
然后，打印一条调试信息，显示"link state change"。
最后，调用usb_clear_port_feature函数来清除端口的链路状态变化特性。
总的来说，这段代码的作用就是当USB端口的链路状态发生变化时，清除该状态变化，并打印一条调试信息。
2.10 第73-77行:处理USB端口配置错误状态的变化
第73-77行：主要作用是处理USB端口配置错误状态的变化。
首先，通过portchange & USB_PORT_STAT_C_CONFIG_ERROR判断USB端口的配置错误状态是否发生变化。如果发生变化，那么进入if语句块。
然后，打印一条警告信息，显示"config error"。
最后，调用usb_clear_port_feature函数来清除端口的配置错误状态变化特性。
总的来说，这段代码的作用就是当USB端口的配置错误状态发生变化时，清除该状态变化，并打印一条警告信息。
2.11 第80-81行:检查USB端口设备的运行时电源管理状态
第80-81行：作用是检查USB端口设备的运行时电源管理状态。
pm_runtime_active函数会返回设备的运行时电源管理（Runtime Power Management，简称RPM）是否处于活动状态。如果处于活动状态，函数会返回true；否则，返回false。
在这段代码中，如果USB端口设备的RPM不处于活动状态，那么函数将立即返回，不会执行后续的代码。这样可以避免在设备处于低功耗状态时执行可能会唤醒设备的操作，从而节省能源。
2.11.1 pm_runtime_active函数
路径：include\linux\pm_runtime.h
/**
* pm_runtime_active - Check whether or not a device is runtime-active.
* @dev: Target device.
*
* Return %true if runtime PM is disabled for @dev or its runtime PM status is
* %RPM_ACTIVE, or %false otherwise.
*
* Note that the return value of this function can only be trusted if it is
* called under the runtime PM lock of @dev or under conditions in which
* runtime PM cannot be either disabled or enabled for @dev and its runtime PM
* status cannot change.
*/
static inline bool pm_runtime_active(struct device *dev)
{
return dev->power.runtime_status == RPM_ACTIVE
|| dev->power.disable_depth;
}
static inline bool pm_runtime_active(struct device *dev) { return true; }
定义了一个名为pm_runtime_active的内联函数，用于检查一个设备是否处于运行时电源管理（Runtime Power Management，简称RPM）的活动状态。
dev：是一个指向设备结构体的指针，表示要检查的目标设备。
dev->power.runtime_status == RPM_ACTIVE：检查设备的运行时电源管理状态是否为RPM_ACTIVE，即设备是否处于活动状态。
dev->power.disable_depth：检查设备的运行时电源管理是否被禁用。如果disable_depth的值大于0，表示运行时电源管理被禁用。
如果设备的运行时电源管理状态为RPM_ACTIVE或者设备的运行时电源管理被禁用，那么函数返回true，表示设备处于活动状态。否则，返回false，表示设备不处于活动状态。
需要注意的是，这个函数的返回值只有在持有设备的运行时电源管理锁，或者在设备的运行时电源管理无法被禁用或启用，且其状态无法改变的情况下，才能被信任。
2.12 第84-85行
第84-85行：作用是判断是否应该忽略对USB端口事件的处理。
port_dev->ignore_event：如果这个值为真，表示应该忽略对USB端口事件的处理。
port_dev->early_stop：如果这个值为真，表示应该提前停止对USB端口事件的处理。
如果这两个条件都满足，那么函数立即返回，不会执行后续的代码。
总的来说，这段代码的作用就是提供一种机制，允许在满足某些条件时跳过对USB端口事件的处理。这可以用于优化性能，或者处理特殊情况。
2.13 第87-88行
第87-88行：主要作用是处理USB集线器的远程唤醒（Remote Wakeup）事件。
hub_handle_remote_wakeup函数会检查是否有远程唤醒事件发生。如果有，那么函数会处理这个事件，并返回1；否则，返回0。
如果hub_handle_remote_wakeup函数返回1，那么就将connect_change设置为1。这表示USB设备的连接状态发生了变化，需要重新枚举设备。
总的来说，这段代码的作用就是当USB设备通过远程唤醒事件改变了其连接状态时，设置connect_change为1，以便后续的代码可以处理这个变化。
2.13.1 hub_handle_remote_wakeup函数
/* Returns 1 if there was a remote wakeup and a connect status change. */
static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
u16 portstatus, u16 portchange)
__must_hold(&port_dev->status_lock)
{
struct usb_port *port_dev = hub->ports[port - 1];
struct usb_device *hdev;
struct usb_device *udev;
int connect_change = 0;
u16 link_state;
int ret;
hdev = hub->hdev;
udev = port_dev->child;
if (!hub_is_superspeed(hdev)) {
if (!(portchange & USB_PORT_STAT_C_SUSPEND))
return 0;
usb_clear_port_feature(hdev, port, USB_PORT_FEAT_C_SUSPEND);
} else {
link_state = portstatus & USB_PORT_STAT_LINK_STATE;
if (!udev || udev->state != USB_STATE_SUSPENDED ||
(link_state != USB_SS_PORT_LS_U0 &&
link_state != USB_SS_PORT_LS_U1 &&
link_state != USB_SS_PORT_LS_U2))
return 0;
}
if (udev) {
/* TRSMRCY = 10 msec */
msleep(10);
usb_unlock_port(port_dev);
ret = usb_remote_wakeup(udev);
usb_lock_port(port_dev);
if (ret < 0)
connect_change = 1;
} else {
ret = -ENODEV;
hub_port_disable(hub, port, 1);
}
dev_dbg(&port_dev->dev, "resume, status %d\n", ret);
return connect_change;
}
主要作用是处理USB集线器的远程唤醒事件。
首先，判断USB设备是否支持超高速模式。如果不支持超高速模式，那么检查portchange & USB_PORT_STAT_C_SUSPEND，如果该值为0，表示没有远程唤醒事件，函数返回0。如果该值不为0，表示有远程唤醒事件，使用usb_clear_port_feature函数清除该状态。
如果USB设备支持超高速模式，那么检查USB设备的状态是否为挂起状态，并且链路状态是否为U0、U1或U2。如果不满足这些条件，表示没有远程唤醒事件，函数返回0。
然后，如果USB端口上有设备连接，那么先等待10毫秒，然后尝试唤醒设备。如果唤醒失败，那么将connect_change设置为1。
如果USB端口上没有设备连接，那么禁用该端口，并将返回值设置为-ENODEV。
最后，打印一条调试信息，并返回connect_change。
总的来说，这个函数的作用就是处理USB集线器的远程唤醒事件。如果有远程唤醒事件，并且唤醒设备失败，那么函数会返回1，表示设备的连接状态发生了变化。
2.14 第96-120行:处理USB3超速（Superspeed）端口热复位
第96-120行：主要作用是处理USB3超速（Superspeed）端口在SS.Inactive状态下需要进行热复位（warm reset）的情况。
(1) 首先，通过hub_port_warm_reset_required函数判断是否需要进行热复位。如果需要，就进入while循环。
(2) 在循环中，首先检查是否已经进行了多次重试（由DETECT_DISCONNECT_TRIES定义）。如果没有达到重试次数，并且udev（表示USB设备）不为空，那么就暂停20毫秒，然后重新获取端口状态，并打印一条调试信息，然后继续下一次循环。
(3) 如果达到了重试次数，或者udev为空，或者端口没有连接，或者设备处于未连接状态，那么就只对端口进行热复位，并打印一条调试信息。如果热复位失败，那么就禁用该端口。
(4) 如果以上条件都不满足，那么就对整个设备进行复位，并打印一条调试信息。复位设备需要先解锁端口，然后锁定设备，然后复位设备，然后解锁设备，最后再锁定端口。并且将connect_change设置为0，表示连接状态没有变化。
总的来说，这段代码的作用就是处理USB3超速端口在SS.Inactive状态下需要进行热复位的情况。如果设备仍然连接在端口上，那么会尝试复位整个设备；否则，只复位端口。
2.14.1 hub_port_warm_reset_required()
static bool hub_port_warm_reset_required(struct usb_hub *hub, int port1,
u16 portstatus)
{
u16 link_state;
if (!hub_is_superspeed(hub->hdev))
return false;
if (test_bit(port1, hub->warm_reset_bits))
return true;
link_state = portstatus & USB_PORT_STAT_LINK_STATE;
return link_state == USB_SS_PORT_LS_SS_INACTIVE
|| link_state == USB_SS_PORT_LS_COMP_MOD;
}
其主要作用是判断一个USB 3.0端口是否处于Inactive或Compliance Mode状态，如果是，那么需要进行热复位（warm reset）恢复。
首先，通过hub_is_superspeed(hub->hdev)判断集线器设备是否为超速（Superspeed）设备。如果不是，那么直接返回false，表示不需要热复位。
然后，通过test_bit(port1, hub->warm_reset_bits)判断指定端口是否已经标记为需要热复位。如果已经标记，那么返回true，表示需要热复位。
接着，通过link_state = portstatus & USB_PORT_STAT_LINK_STATE获取端口的链接状态。
最后，判断链接状态是否为USB_SS_PORT_LS_SS_INACTIVE或USB_SS_PORT_LS_COMP_MOD。如果是，那么返回true，表示需要热复位。
总的来说，这个函数的作用就是判断一个USB 3.0端口是否需要进行热复位。如果端口处于Inactive或Compliance Mode状态，或者已经被标记为需要热复位，那么就需要进行热复位。
2.14.2 hub_port_reset()
/* Handle port reset and port warm(BH) reset (for USB3 protocol ports) */
static int hub_port_reset(struct usb_hub *hub, int port1,
struct usb_device *udev, unsigned int delay, bool warm)
{
int i, status;
u16 portchange, portstatus;
struct usb_port *port_dev = hub->ports[port1 - 1];
int reset_recovery_time;
if (!hub_is_superspeed(hub->hdev)) {
if (warm) {
dev_err(hub->intfdev, "only USB3 hub support "
"warm reset\n");
return -EINVAL;
}
/* Block EHCI CF initialization during the port reset.
* Some companion controllers don't like it when they mix.
*/
down_read(&ehci_cf_port_reset_rwsem);
} else if (!warm) {
/*
* If the caller hasn't explicitly requested a warm reset,
* double check and see if one is needed.
*/
if (usb_hub_port_status(hub, port1, &portstatus,
&portchange) == 0)
if (hub_port_warm_reset_required(hub, port1,
portstatus))
warm = true;
}
clear_bit(port1, hub->warm_reset_bits);
/* Reset the port */
for (i = 0; i < PORT_RESET_TRIES; i++) {
status = set_port_feature(hub->hdev, port1, (warm ?
USB_PORT_FEAT_BH_PORT_RESET :
USB_PORT_FEAT_RESET));
if (status == -ENODEV) {
; /* The hub is gone */
} else if (status) {
dev_err(&port_dev->dev,
"cannot %sreset (err = %d)\n",
warm ? "warm " : "", status);
} else {
status = hub_port_wait_reset(hub, port1, udev, delay,
warm);
if (status && status != -ENOTCONN && status != -ENODEV)
dev_dbg(hub->intfdev,
"port_wait_reset: err = %d\n",
status);
}
/*
* Check for disconnect or reset, and bail out after several
* reset attempts to avoid warm reset loop.
*/
if (status == 0 || status == -ENOTCONN || status == -ENODEV ||
(status == -EBUSY && i == PORT_RESET_TRIES - 1)) {
usb_clear_port_feature(hub->hdev, port1,
USB_PORT_FEAT_C_RESET);
if (!hub_is_superspeed(hub->hdev))
goto done;
usb_clear_port_feature(hub->hdev, port1,
USB_PORT_FEAT_C_BH_PORT_RESET);
usb_clear_port_feature(hub->hdev, port1,
USB_PORT_FEAT_C_PORT_LINK_STATE);
if (udev)
usb_clear_port_feature(hub->hdev, port1,
USB_PORT_FEAT_C_CONNECTION);
/*
* If a USB 3.0 device migrates from reset to an error
* state, re-issue the warm reset.
*/
if (usb_hub_port_status(hub, port1,
&portstatus, &portchange) < 0)
goto done;
if (!hub_port_warm_reset_required(hub, port1,
portstatus))
goto done;
/*
* If the port is in SS.Inactive or Compliance Mode, the
* hot or warm reset failed. Try another warm reset.
*/
if (!warm) {
dev_dbg(&port_dev->dev,
"hot reset failed, warm reset\n");
warm = true;
}
}
dev_dbg(&port_dev->dev,
"not enabled, trying %sreset again...\n",
warm ? "warm " : "");
delay = HUB_LONG_RESET_TIME;
}
dev_err(&port_dev->dev, "Cannot enable. Maybe the USB cable is bad?\n");
done:
if (status == 0) {
if (port_dev->quirks & USB_PORT_QUIRK_FAST_ENUM)
usleep_range(10000, 12000);
else {
/* TRSTRCY = 10 ms; plus some extra */
reset_recovery_time = 10 + 40;
/* Hub needs extra delay after resetting its port. */
if (hub->hdev->quirks & USB_QUIRK_HUB_SLOW_RESET)
reset_recovery_time += 100;
msleep(reset_recovery_time);
}
if (udev) {
struct usb_hcd *hcd = bus_to_hcd(udev->bus);
update_devnum(udev, 0);
/* The xHC may think the device is already reset,
* so ignore the status.
*/
if (hcd->driver->reset_device)
hcd->driver->reset_device(hcd, udev);
usb_set_device_state(udev, USB_STATE_DEFAULT);
}
} else {
if (udev)
usb_set_device_state(udev, USB_STATE_NOTATTACHED);
}
if (!hub_is_superspeed(hub->hdev))
up_read(&ehci_cf_port_reset_rwsem);
return status;
}
该函数用于对USB集线器的端口进行复位操作。复位操作包括常规复位和热复位两种，热复位主要针对USB3.0协议的端口。复位操作主要用于设备枚举和错误恢复。
以下是这段代码的详细过程和作用：
首先，判断是否为超速设备。如果不是，并且进行的是热复位，打印错误信息并返回。如果是超速设备，但没有明确要求进行热复位，那么检查端口状态，如果需要，设定进行热复位。
清除端口的热复位标记。
进行端口复位操作，复位操作可能需要多次尝试。在每次尝试中，首先设置端口复位特性，然后等待端口复位完成。
检查复位操作的结果。如果复位成功，或者端口已经断开连接，或者端口已经禁用，或者复位操作繁忙并且已经达到最大尝试次数，那么清除端口的复位状态变化特性，并且如果是超速设备，还需要清除端口的热复位状态变化特性和链路状态变化特性。如果端口在复位后进入了错误状态，那么需要再次进行热复位。
如果复位操作失败，那么打印错误信息并返回。
如果复位操作成功，那么等待一段时间以便设备恢复，然后更新设备的设备号，并将设备状态设置为默认状态。
如果复位操作失败，那么将设备状态设置为未连接状态。
总的来说，这段代码的作用就是对USB集线器的端口进行复位操作，以便设备枚举和错误恢复。
2.14.2.1 update_devnum（）
static void update_devnum(struct usb_device *udev, int devnum)
{
/* The address for a WUSB device is managed by wusbcore. */
if (!udev->wusb)
udev->devnum = devnum;
if (!udev->devaddr)
udev->devaddr = (u8)devnum;
}
主要作用是更新USB设备的设备编号（device number）。
以下是这段代码的详细过程和作用：
首先检查udev->wusb的值。如果udev->wusb为0，表示这不是一个无线USB（WUSB）设备，那么就将输入参数devnum赋值给udev->devnum，作为设备的新编号。
然后检查udev->devaddr的值。如果udev->devaddr为0，表示设备的地址还没有被设置，那么就将输入参数devnum的值（转换为u8类型）赋值给udev->devaddr，作为设备的新地址。
总的来说，这个函数的作用就是更新USB设备的设备编号和设备地址。对于无线USB设备，其设备编号是由无线USB核心管理的，所以这个函数不会更新无线USB设备的设备编号。
2.14.2.2 usb_set_device_state（）
void usb_set_device_state(struct usb_device *udev,
enum usb_device_state new_state)
{
unsigned long flags;
int wakeup = -1;
spin_lock_irqsave(&device_state_lock, flags);
if (udev->state == USB_STATE_NOTATTACHED)
; /* do nothing */
else if (new_state != USB_STATE_NOTATTACHED) {
/* root hub wakeup capabilities are managed out-of-band
* and may involve silicon errata ... ignore them here.
*/
if (udev->parent) {
if (udev->state == USB_STATE_SUSPENDED
|| new_state == USB_STATE_SUSPENDED)
; /* No change to wakeup settings */
else if (new_state == USB_STATE_CONFIGURED)
wakeup = (udev->quirks &
USB_QUIRK_IGNORE_REMOTE_WAKEUP) ? 0 :
udev->actconfig->desc.bmAttributes &
USB_CONFIG_ATT_WAKEUP;
else
wakeup = 0;
}
if (udev->state == USB_STATE_SUSPENDED &&
new_state != USB_STATE_SUSPENDED)
udev->active_duration -= jiffies;
else if (new_state == USB_STATE_SUSPENDED &&
udev->state != USB_STATE_SUSPENDED)
udev->active_duration += jiffies;
udev->state = new_state;
} else
recursively_mark_NOTATTACHED(udev);
spin_unlock_irqrestore(&device_state_lock, flags);
if (wakeup >= 0)
device_set_wakeup_capable(&udev->dev, wakeup);
}
EXPORT_SYMBOL_GPL(usb_set_device_state);
主要用于改变USB设备的状态。
以下是这段代码的详细过程和作用：
函数首先获取device_state_lock自旋锁，以保护设备状态的修改操作。
然后检查设备当前的状态是否为USB_STATE_NOTATTACHED。如果是，函数不做任何操作。
如果新的状态new_state不为USB_STATE_NOTATTACHED，则进一步检查设备的状态。如果设备不是根集线器，并且设备当前状态或新的状态为USB_STATE_SUSPENDED，则不改变设备的唤醒设置。如果新的状态为USB_STATE_CONFIGURED，则根据设备是否支持远程唤醒（USB_QUIRK_IGNORE_REMOTE_WAKEUP）和配置描述符的唤醒属性（USB_CONFIG_ATT_WAKEUP）来设置唤醒标志wakeup。否则，将唤醒标志wakeup设置为0。
接着，如果设备当前状态为USB_STATE_SUSPENDED并且新的状态不为USB_STATE_SUSPENDED，则从设备的活动持续时间中减去当前时间。如果新的状态为USB_STATE_SUSPENDED并且设备当前状态不为USB_STATE_SUSPENDED，则向设备的活动持续时间中添加当前时间。
最后，将设备的状态设置为新的状态。
如果新的状态为USB_STATE_NOTATTACHED，则调用recursively_mark_NOTATTACHED函数将设备及其所有子设备的状态都设置为USB_STATE_NOTATTACHED。
释放device_state_lock自旋锁。
如果唤醒标志wakeup大于等于0，调用device_set_wakeup_capable函数设置设备的唤醒能力。
总的来说，这个函数的作用就是改变USB设备的状态，并在需要时更新设备的唤醒设置和活动持续时间。
2.14.3 hub_port_disable()
static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
{
struct usb_port *port_dev = hub->ports[port1 - 1];
struct usb_device *hdev = hub->hdev;
int ret = 0;
if (!hub->error) {
if (hub_is_superspeed(hub->hdev)) {
hub_usb3_port_prepare_disable(hub, port_dev);
ret = hub_set_port_link_state(hub, port_dev->portnum,
USB_SS_PORT_LS_U3);
} else {
ret = usb_clear_port_feature(hdev, port1,
USB_PORT_FEAT_ENABLE);
}
}
if (port_dev->child && set_state)
usb_set_device_state(port_dev->child, USB_STATE_NOTATTACHED);
if (ret && ret != -ENODEV)
dev_err(&port_dev->dev, "cannot disable (err = %d)\n", ret);
return ret;
}
主要用于关闭指定的USB端口。以下是这段代码的详细过程和作用：
函数首先获取指定端口的设备和集线器对象。
然后，检查集线器是否有错误。如果没有错误，那么就关闭端口。关闭端口的方式取决于集线器是否支持超速（Superspeed）模式。如果支持超速模式，那么就调用hub_usb3_port_prepare_disable函数和hub_set_port_link_state函数将端口的链接状态设置为U3（U3是USB3.0协议中的一种电源管理状态，表示端口被关闭）。如果不支持超速模式，那么就调用usb_clear_port_feature函数清除端口的使能特性，以关闭端口。
接着，如果端口上有设备连接，并且set_state参数为真，那么就将设备的状态设置为USB_STATE_NOTATTACHED，表示设备已经从端口上断开。
最后，如果关闭端口失败，并且错误码不是-ENODEV（表示设备不存在），那么就打印一条错误信息。
总的来说，这个函数的作用就是关闭指定的USB端口。如果端口上有设备连接，那么还会将设备的状态设置为已断开。
2.14.3.1 hub_usb3_port_prepare_disable()
static void hub_usb3_port_prepare_disable(struct usb_hub *hub,
struct usb_port *port_dev)
{
struct usb_device *udev = port_dev->child;
int ret;
if (udev && udev->port_is_suspended && udev->do_remote_wakeup) {
ret = hub_set_port_link_state(hub, port_dev->portnum,
USB_SS_PORT_LS_U0);
if (!ret) {
msleep(USB_RESUME_TIMEOUT);
ret = usb_disable_remote_wakeup(udev);
}
if (ret)
dev_warn(&udev->dev,
"Port disable: can't disable remote wake\n");
udev->do_remote_wakeup = 0;
}
}
主要用于为关闭USB3.0端口做准备工作，特别是确保关闭端口的远程唤醒功能。
以下是这段代码的详细过程和作用：
函数首先检查端口上是否有设备连接，并且设备是否处于挂起状态，以及设备的远程唤醒功能是否已经打开。如果这三个条件都满足，那么就进入if语句块。
在if语句块中，首先调用hub_set_port_link_state函数将端口的链接状态设置为U0（U0是USB3.0协议中的一种链接状态，表示端口处于活动状态）。然后等待一段时间（由USB_RESUME_TIMEOUT定义），以便设备从挂起状态恢复。
接着，调用usb_disable_remote_wakeup函数关闭设备的远程唤醒功能。如果关闭远程唤醒功能失败，那么就打印一条警告信息。
最后，无论关闭远程唤醒功能是否成功，都将设备的do_remote_wakeup标志设置为0，表示设备的远程唤醒功能已经关闭。
总的来说，这个函数的作用就是为关闭USB3.0端口做准备工作，特别是确保关闭端口的远程唤醒功能。这是因为在USB3.0协议中，端口的远程唤醒功能需要在端口被关闭之前关闭。
2.14.3.2 hub_set_port_link_state()
static int hub_set_port_link_state(struct usb_hub *hub, int port1,
unsigned int link_status)
{
return set_port_feature(hub->hdev,
port1 | (link_status << 3),
USB_PORT_FEAT_LINK_STATE);
}
主要用于设置USB集线器端口的链路状态。
以下是这段代码的详细过程和作用：
函数接收三个参数：一个指向usb_hub结构体的指针hub，表示要操作的USB集线器；一个整数port1，表示要操作的端口号；一个无符号整数link_status，表示要设置的链路状态。
在函数中，首先通过移位操作（link_status << 3）将link_status的值左移3位。然后，将移位后的link_status的值和port1的值进行按位或操作。这样可以将port1的值和link_status的值合并到一个16位的整数中。
最后，调用set_port_feature函数，将合并后的值和USB_PORT_FEAT_LINK_STATE作为参数传递给set_port_feature函数。set_port_feature函数会将USB_PORT_FEAT_LINK_STATE特性设置到指定的端口上，从而改变端口的链路状态。
总的来说，这个函数的作用就是设置USB集线器端口的链路状态。这是通过调用set_port_feature函数实现的，该函数会将指定的特性设置到端口上。
2.14.4 usb_reset_device()
int usb_reset_device(struct usb_device *udev)
{
int ret;
int i;
unsigned int noio_flag;
struct usb_port *port_dev;
struct usb_host_config *config = udev->actconfig;
struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
if (udev->state == USB_STATE_NOTATTACHED) {
dev_dbg(&udev->dev, "device reset not allowed in state %d\n",
udev->state);
return -EINVAL;
}
if (!udev->parent) {
/* this requires hcd-specific logic; see ohci_restart() */
dev_dbg(&udev->dev, "%s for root hub!\n", __func__);
return -EISDIR;
}
if (udev->reset_in_progress)
return -EINPROGRESS;
udev->reset_in_progress = 1;
port_dev = hub->ports[udev->portnum - 1];
/*
* Don't allocate memory with GFP_KERNEL in current
* context to avoid possible deadlock if usb mass
* storage interface or usbnet interface(iSCSI case)
* is included in current configuration. The easist
* approach is to do it for every device reset,
* because the device 'memalloc_noio' flag may have
* not been set before reseting the usb device.
*/
noio_flag = memalloc_noio_save();
/* Prevent autosuspend during the reset */
usb_autoresume_device(udev);
if (config) {
for (i = 0; i < config->desc.bNumInterfaces; ++i) {
struct usb_interface *cintf = config->interface[i];
struct usb_driver *drv;
int unbind = 0;
if (cintf->dev.driver) {
drv = to_usb_driver(cintf->dev.driver);
if (drv->pre_reset && drv->post_reset)
unbind = (drv->pre_reset)(cintf);
else if (cintf->condition ==
USB_INTERFACE_BOUND)
unbind = 1;
if (unbind)
usb_forced_unbind_intf(cintf);
}
}
}
usb_lock_port(port_dev);
ret = usb_reset_and_verify_device(udev);
usb_unlock_port(port_dev);
if (config) {
for (i = config->desc.bNumInterfaces - 1; i >= 0; --i) {
struct usb_interface *cintf = config->interface[i];
struct usb_driver *drv;
int rebind = cintf->needs_binding;
if (!rebind && cintf->dev.driver) {
drv = to_usb_driver(cintf->dev.driver);
if (drv->post_reset)
rebind = (drv->post_reset)(cintf);
else if (cintf->condition ==
USB_INTERFACE_BOUND)
rebind = 1;
if (rebind)
cintf->needs_binding = 1;
}
}
/* If the reset failed, hub_wq will unbind drivers later */
if (ret == 0)
usb_unbind_and_rebind_marked_interfaces(udev);
}
usb_autosuspend_device(udev);
memalloc_noio_restore(noio_flag);
udev->reset_in_progress = 0;
return ret;
}
EXPORT_SYMBOL_GPL(usb_reset_device);
主要用于对USB设备进行复位操作。
以下是这段代码的详细过程和作用：
函数首先检查设备是否处于USB_STATE_NOTATTACHED状态。如果是，那么打印一条调试信息并返回错误。
接着，如果设备是根集线器，那么打印一条调试信息并返回错误。
如果设备已经在进行复位操作，那么返回-EINPROGRESS，表示复位操作正在进行中。
然后，获取设备所连接的端口和集线器。
为了避免在当前上下文中分配内存可能导致的死锁，保存并改变内存分配的标志。
调用usb_autoresume_device函数，防止设备在复位操作期间自动挂起。
如果设备有活动的配置，那么遍历配置中的所有接口，对每个接口进行以下操作：
如果接口已经绑定到驱动，并且驱动提供了pre_reset和post_reset回调，那么调用pre_reset回调，并根据回调的返回值决定是否需要解绑接口；
如果接口已经绑定到驱动，但驱动没有提供pre_reset和post_reset回调，那么解绑接口；
如果接口没有绑定到驱动，那么不做任何操作。
对设备进行复位和验证操作。
如果设备有活动的配置，那么再次遍历配置中的所有接口，对每个接口进行以下操作：
如果接口需要绑定，并且接口已经绑定到驱动，并且驱动提供了post_reset回调，那么调用post_reset回调，并根据回调的返回值决定是否需要重新绑定接口；
如果接口需要绑定，并且接口已经绑定到驱动，但驱动没有提供post_reset回调，那么重新绑定接口；
如果接口不需要绑定，那么不做任何操作。
如果复位操作成功，那么对所有需要重新绑定的接口进行解绑和绑定操作。
调用usb_autosuspend_device函数，允许设备在空闲时自动挂起。
恢复内存分配的标志。
清除设备的复位标志。
总的来说，这个函数的作用就是对USB设备进行复位操作。在复位操作开始和结束时，会通知所有绑定到设备的驱动。如果驱动没有提供相应的回调，那么会解绑驱动并在复位操作结束后重新绑定驱动。
2.15 第122-123行:处理USB集线器端口的连接状态变化
第122-123行：主要作用是处理USB集线器端口的连接状态变化。
connect_change：这是一个布尔变量，如果其值为真，表示USB设备的连接状态发生了变化。
hub_port_connect_change：这是一个函数，用于处理USB设备的连接状态变化。它接收四个参数：一个指向usb_hub结构体的指针hub，表示要操作的USB集线器；一个整数port1，表示要操作的端口号；一个整数portstatus，表示端口的当前状态；一个整数portchange，表示端口状态的变化。
如果connect_change的值为真，那么就调用hub_port_connect_change函数，处理USB设备的连接状态变化。这可能包括设备的连接、断开连接、重新枚举等操作。
三、总结
以上是对USB port event的处理过程。后面将继续分析，如果USB device connect 发生变化的处理过程，例如USB设备插入、USB设备拔出等链接发生变化情况的处理。 由hub_port_connect_change()函数处理。请看篇分析。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
