＜kernel＞kernel 6.4 USB-之-hub_port_connect()分析
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
一、前言
本章主要分析的是在Linux内核的USB驱动中，用于处理USB端口连接的函数hub_port_connect。主要过程和作用包括：
(1) 断开此端口下的任何现有设备。
(2) 检查端口状态，如果连接不稳定或者没有设备连接，可能会尝试恢复端口电源（如果端口支持电源切换的话）。
(3) 为新连接的设备进行初始化，包括分配设备编号、设备状态设定、设备速度设定等。
(4) 对端口进行多次初始化尝试（由PORT_INIT_TRIES定义），在每次尝试中都会重置设备并获取描述符，如果设备支持延迟初始化，则会等待一段时间。
(5) 检查新连接的设备是否运行在其可能的最高速度下。如果不是，可能会进行一些处理。
(6) 将新设备添加到父集线器的子设备数组中，使其全局可访问。
(7) 如果新设备成功添加，会通知USB PHY（如果存在的话）设备已连接。
(8) 如果在尝试过程中发生错误，会禁用端口并释放设备。
(9) 最后，如果设备无法枚举并且端口没有被接管，会打印错误信息。如果HCD驱动支持，可能会放弃端口的控制权。
总的来说，这个函数的主要作用是处理USB端口的连接事件，包括设备的初始化、枚举和错误处理等。
二、hub_port_connect()函数
hub_port_connect()函数内容如下：
static void hub_port_connect(struct usb_hub *hub, int port1, u16 portstatus,
u16 portchange)
{
int status = -ENODEV;
int i;
unsigned unit_load;
struct usb_device *hdev = hub->hdev;
struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
struct usb_port *port_dev = hub->ports[port1 - 1];
struct usb_device *udev = port_dev->child;
static int unreliable_port = -1;
bool retry_locked;
/* Disconnect any existing devices under this port */
if (udev) {
if (hcd->usb_phy && !hdev->parent)
usb_phy_notify_disconnect(hcd->usb_phy, udev->speed);
usb_disconnect(&port_dev->child);
}
/* We can forget about a "removed" device when there's a physical
* disconnect or the connect status changes.
*/
if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
(portchange & USB_PORT_STAT_C_CONNECTION))
clear_bit(port1, hub->removed_bits);
if (portchange & (USB_PORT_STAT_C_CONNECTION |
USB_PORT_STAT_C_ENABLE)) {
status = hub_port_debounce_be_stable(hub, port1);
if (status < 0) {
if (status != -ENODEV &&
port1 != unreliable_port &&
printk_ratelimit())
dev_err(&port_dev->dev, "connect-debounce failed\n");
portstatus &= ~USB_PORT_STAT_CONNECTION;
unreliable_port = port1;
} else {
portstatus = status;
}
}
/* Return now if debouncing failed or nothing is connected or
* the device was "removed".
*/
if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
test_bit(port1, hub->removed_bits)) {
/*
* maybe switch power back on (e.g. root hub was reset)
* but only if the port isn't owned by someone else.
*/
if (hub_is_port_power_switchable(hub)
&& !usb_port_is_power_on(hub, portstatus)
&& !port_dev->port_owner)
set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
if (portstatus & USB_PORT_STAT_ENABLE)
goto done;
return;
}
if (hub_is_superspeed(hub->hdev))
unit_load = 150;
else
unit_load = 100;
status = 0;
for (i = 0; i < PORT_INIT_TRIES; i++) {
if (hub_port_stop_enumerate(hub, port1, i)) {
status = -ENODEV;
break;
}
usb_lock_port(port_dev);
mutex_lock(hcd->address0_mutex);
retry_locked = true;
/* reallocate for each attempt, since references
* to the previous one can escape in various ways
*/
udev = usb_alloc_dev(hdev, hdev->bus, port1);
if (!udev) {
dev_err(&port_dev->dev,
"couldn't allocate usb_device\n");
mutex_unlock(hcd->address0_mutex);
usb_unlock_port(port_dev);
goto done;
}
usb_set_device_state(udev, USB_STATE_POWERED);
udev->bus_mA = hub->mA_per_port;
udev->level = hdev->level + 1;
udev->wusb = hub_is_wusb(hub);
/* Devices connected to SuperSpeed hubs are USB 3.0 or later */
if (hub_is_superspeed(hub->hdev))
udev->speed = USB_SPEED_SUPER;
else
udev->speed = USB_SPEED_UNKNOWN;
choose_devnum(udev);
if (udev->devnum <= 0) {
status = -ENOTCONN; /* Don't retry */
goto loop;
}
/* reset (non-USB 3.0 devices) and get descriptor */
status = hub_port_init(hub, udev, port1, i);
if (status < 0)
goto loop;
mutex_unlock(hcd->address0_mutex);
usb_unlock_port(port_dev);
retry_locked = false;
if (udev->quirks & USB_QUIRK_DELAY_INIT)
msleep(2000);
/* consecutive bus-powered hubs aren't reliable; they can
* violate the voltage drop budget. if the new child has
* a "powered" LED, users should notice we didn't enable it
* (without reading syslog), even without per-port LEDs
* on the parent.
*/
if (udev->descriptor.bDeviceClass == USB_CLASS_HUB
&& udev->bus_mA <= unit_load) {
u16 devstat;
status = usb_get_std_status(udev, USB_RECIP_DEVICE, 0,
&devstat);
if (status) {
dev_dbg(&udev->dev, "get status %d ?\n", status);
goto loop_disable;
}
if ((devstat & (1 << USB_DEVICE_SELF_POWERED)) == 0) {
dev_err(&udev->dev,
"can't connect bus-powered hub "
"to this port\n");
if (hub->has_indicators) {
hub->indicator[port1-1] =
INDICATOR_AMBER_BLINK;
queue_delayed_work(
system_power_efficient_wq,
&hub->leds, 0);
}
status = -ENOTCONN; /* Don't retry */
goto loop_disable;
}
}
/* check for devices running slower than they could */
if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0200
&& udev->speed == USB_SPEED_FULL
&& highspeed_hubs != 0)
check_highspeed(hub, udev, port1);
/* Store the parent's children[] pointer. At this point
* udev becomes globally accessible, although presumably
* no one will look at it until hdev is unlocked.
*/
status = 0;
mutex_lock(&usb_port_peer_mutex);
/* We mustn't add new devices if the parent hub has
* been disconnected; we would race with the
* recursively_mark_NOTATTACHED() routine.
*/
spin_lock_irq(&device_state_lock);
if (hdev->state == USB_STATE_NOTATTACHED)
status = -ENOTCONN;
else
port_dev->child = udev;
spin_unlock_irq(&device_state_lock);
mutex_unlock(&usb_port_peer_mutex);
/* Run it through the hoops (find a driver, etc) */
if (!status) {
status = usb_new_device(udev);
if (status) {
mutex_lock(&usb_port_peer_mutex);
spin_lock_irq(&device_state_lock);
port_dev->child = NULL;
spin_unlock_irq(&device_state_lock);
mutex_unlock(&usb_port_peer_mutex);
} else {
if (hcd->usb_phy && !hdev->parent)
usb_phy_notify_connect(hcd->usb_phy,
udev->speed);
}
}
if (status)
goto loop_disable;
status = hub_power_remaining(hub);
if (status)
dev_dbg(hub->intfdev, "%dmA power budget left\n", status);
return;
loop_disable:
hub_port_disable(hub, port1, 1);
loop:
usb_ep0_reinit(udev);
release_devnum(udev);
hub_free_dev(udev);
if (retry_locked) {
mutex_unlock(hcd->address0_mutex);
usb_unlock_port(port_dev);
}
usb_put_dev(udev);
if ((status == -ENOTCONN) || (status == -ENOTSUPP))
break;
/* When halfway through our retry count, power-cycle the port */
if (i == (PORT_INIT_TRIES - 1) / 2) {
dev_info(&port_dev->dev, "attempt power cycle\n");
usb_hub_set_port_power(hdev, hub, port1, false);
msleep(2 * hub_power_on_good_delay(hub));
usb_hub_set_port_power(hdev, hub, port1, true);
msleep(hub_power_on_good_delay(hub));
}
}
if (hub->hdev->parent ||
!hcd->driver->port_handed_over ||
!(hcd->driver->port_handed_over)(hcd, port1)) {
if (status != -ENOTCONN && status != -ENODEV)
dev_err(&port_dev->dev,
"unable to enumerate USB device\n");
}
done:
hub_port_disable(hub, port1, 1);
if (hcd->driver->relinquish_port && !hub->hdev->parent) {
if (status != -ENOTCONN && status != -ENODEV)
hcd->driver->relinquish_port(hcd, port1);
}
}
下面就对hub_port_connect()函数内容详细分析：
2.1 第7-10行：创建和初始化一些指针变量
第7-10行：主要过程内容和作用是创建和初始化一些指针变量，这些变量用于后续的USB端口和设备处理。
struct usb_device *hdev = hub->hdev;：创建一个指向USB设备的指针hdev，并将其初始化为当前hub的设备。这个设备代表的是USB集线器自身。
struct usb_hcd *hcd = bus_to_hcd(hdev->bus);：创建一个指向USB主控制器设备（Host Controller Device，HCD）的指针hcd，并将其初始化为hdev所在的总线对应的HCD。HCD是硬件设备，负责管理USB设备的物理连接和数据传输。
struct usb_port *port_dev = hub->ports[port1 - 1];：创建一个指向USB端口的指针port_dev，并将其初始化为当前hub的第port1 - 1个端口。这个端口是我们要处理的USB端口。
struct usb_device *udev = port_dev->child;：创建一个指向USB设备的指针udev，并将其初始化为port_dev端口上的子设备。这个设备是我们要处理的USB设备。
static int unreliable_port = -1;：创建一个静态整数变量unreliable_port，并将其初始化为-1。这个变量用于标记不可靠的端口。
总的来说，这段代码的作用是创建和初始化一些用于USB设备和端口处理的变量。
2.2 第15-19行：断开此USB端口下的任何现有设备
第15-19行：主要作用是断开此USB端口下的任何现有设备。
if (udev) { … }：这是一个条件判断，如果udev（即，此USB端口下的子设备）存在，那么就执行大括号中的代码。
if (hcd->usb_phy && !hdev->parent) usb_phy_notify_disconnect(hcd->usb_phy, udev->speed);：这是一个嵌套的条件判断，如果HCD（即，主控制器设备）有PHY（即，物理接口），并且hdev（即，当前hub的设备，也就是USB集线器自身）没有父设备，那么就调用usb_phy_notify_disconnect函数，通知PHY设备已经断开。这个函数的两个参数是PHY和udev的速度。
usb_disconnect(&port_dev->child);：调用usb_disconnect函数，断开port_dev（即，此USB端口）下的子设备。这个函数的参数是指向port_dev子设备的指针。
总的来说，这段代码的作用是断开此USB端口下的任何现有设备。这是在处理USB端口连接事件时的第一步，为新设备的连接做准备。
2.2.1 usb_phy_notify_disconnect()函数
路径：include\linux\usb\phy.h
static inline int
usb_phy_notify_disconnect(struct usb_phy *x, enum usb_device_speed speed)
{
if (x && x->notify_disconnect)
return x->notify_disconnect(x, speed);
else
return 0;
}
该函数用于通知USB PHY（Physical Interface，物理接口）设备已断开连接。如果PHY设备存在，并且有处理断开连接的方法，那么就调用这个方法；否则，就什么都不做。
2.2.2 usb_phy_notify_disconnect()函数
void usb_disconnect(struct usb_device **pdev)
{
struct usb_port *port_dev = NULL;
struct usb_device *udev = *pdev;
struct usb_hub *hub = NULL;
int port1 = 1;
/* mark the device as inactive, so any further urb submissions for
* this device (and any of its children) will fail immediately.
* this quiesces everything except pending urbs.
*/
usb_set_device_state(udev, USB_STATE_NOTATTACHED);
dev_info(&udev->dev, "USB disconnect, device number %d\n",
udev->devnum);
/*
* Ensure that the pm runtime code knows that the USB device
* is in the process of being disconnected.
*/
pm_runtime_barrier(&udev->dev);
usb_lock_device(udev);
hub_disconnect_children(udev);
/* deallocate hcd/hardware state ... nuking all pending urbs and
* cleaning up all state associated with the current configuration
* so that the hardware is now fully quiesced.
*/
dev_dbg(&udev->dev, "unregistering device\n");
usb_disable_device(udev, 0);
usb_hcd_synchronize_unlinks(udev);
if (udev->parent) {
port1 = udev->portnum;
hub = usb_hub_to_struct_hub(udev->parent);
port_dev = hub->ports[port1 - 1];
sysfs_remove_link(&udev->dev.kobj, "port");
sysfs_remove_link(&port_dev->dev.kobj, "device");
/*
* As usb_port_runtime_resume() de-references udev, make
* sure no resumes occur during removal
*/
if (!test_and_set_bit(port1, hub->child_usage_bits))
pm_runtime_get_sync(&port_dev->dev);
}
usb_remove_ep_devs(&udev->ep0);
usb_unlock_device(udev);
/* Unregister the device. The device driver is responsible
* for de-configuring the device and invoking the remove-device
* notifier chain (used by usbfs and possibly others).
*/
device_del(&udev->dev);
/* Free the device number and delete the parent's children[]
* (or root_hub) pointer.
*/
release_devnum(udev);
/* Avoid races with recursively_mark_NOTATTACHED() */
spin_lock_irq(&device_state_lock);
*pdev = NULL;
spin_unlock_irq(&device_state_lock);
if (port_dev && test_and_clear_bit(port1, hub->child_usage_bits))
pm_runtime_put(&port_dev->dev);
hub_free_dev(udev);
put_device(&udev->dev);
}
主要用于处理USB设备断开连接的情况。函数的详细过程内容和作用如下：
(1) 首先，函数接收一个指向USB设备指针的指针作为参数，然后定义了一些局部变量，包括指向USB端口、USB设备和USB集线器的指针，以及一个整数变量port1。
(2) 然后，函数将USB设备的状态设置为USB_STATE_NOTATTACHED，表示设备已经断开连接。并输出一条信息，显示设备号和断开连接的状态。
(3) 接着，函数调用pm_runtime_barrier函数，确保电源管理运行时代码知道USB设备正在断开连接。
(4) 函数接着锁定设备，断开所有子设备的连接，禁用设备，并同步所有未完成的USB请求块（URB）。
(5) 如果设备有父设备，即设备是连接在一个USB集线器上的，那么函数会获取设备所在的端口号和集线器，然后移除设备和端口之间的sysfs链接。
(6) 函数接着移除设备的端点0的所有设备文件，然后解锁设备。
(7) 接下来，函数调用device_del函数，注销设备。这个过程中，设备驱动程序负责对设备进行去配置，并调用移除设备的通知链。
(8) 函数接着释放设备号，并删除父设备的children数组中对应的指针。
(9) 最后，函数清除端口的使用标记，释放设备占用的内存，并减少设备的引用计数。
总的来说，这个函数的作用是处理USB设备的断开连接，包括设备状态的设置、设备的锁定和解锁、设备的禁用、设备的注销、设备号的释放、设备内存的释放等。
2.3 第24-26行：在USB端口的物理断开或连接状态发生改变时忽略"removed"标记
第24-26行：主要作用是在USB端口的物理断开或连接状态发生改变时，忽略被标记为"removed"的设备。
if (!(portstatus & USB_PORT_STAT_CONNECTION) || (portchange & USB_PORT_STAT_C_CONNECTION))：这是一个条件判断。如果端口的状态portstatus中没有设置USB_PORT_STAT_CONNECTION标志位，或者端口的状态改变portchange中设置了USB_PORT_STAT_C_CONNECTION标志位，那么就执行大括号中的代码。USB_PORT_STAT_CONNECTION标志位表示端口的连接状态，USB_PORT_STAT_C_CONNECTION标志位表示端口的连接状态发生了改变。
clear_bit(port1, hub->removed_bits);：调用clear_bit函数，清除hub->removed_bits中的第port1位。hub->removed_bits是一个位图，用于标记哪些端口的设备被移除了。
总的来说，这段代码的作用是在USB端口的物理断开或连接状态发生改变时，忽略被标记为"removed"的设备。这是处理USB端口连接事件的一部分，用于准备新设备的连接。
2.4 第28-41行：USB端口的连接和使能状态发生变化稳定性检测
第28-41行：主要作用是处理USB端口的连接和使能状态发生变化的情况，并进行稳定性检测。
if (portchange & (USB_PORT_STAT_C_CONNECTION | USB_PORT_STAT_C_ENABLE)) {…}：这是一个条件判断。如果端口状态改变portchange中设置了USB_PORT_STAT_C_CONNECTION或USB_PORT_STAT_C_ENABLE标志位，那么就执行大括号中的代码。USB_PORT_STAT_C_CONNECTION标志位表示端口的连接状态发生了改变，USB_PORT_STAT_C_ENABLE标志位表示端口的使能状态发生了改变。
status = hub_port_debounce_be_stable(hub, port1);：调用hub_port_debounce_be_stable函数，对端口进行稳定性检测，然后将结果赋值给status。
if (status < 0) {…}：这是一个条件判断。如果status小于0，表示稳定性检测失败，那么就执行大括号中的代码。
if (status != -ENODEV && port1 != unreliable_port && printk_ratelimit()) dev_err(&port_dev->dev, “connect-debounce failed\n”);：这是一个嵌套的条件判断。如果status不等于-ENODEV，并且端口号port1不等于unreliable_port，并且printk_ratelimit函数返回真，那么就调用dev_err函数，输出一条错误信息，表示连接稳定性检测失败。
portstatus &= ~USB_PORT_STAT_CONNECTION;：清除portstatus中的USB_PORT_STAT_CONNECTION标志位，表示端口已经断开连接。
unreliable_port = port1;：将unreliable_port设置为port1，表示port1是不可靠的端口。
else { portstatus = status; }：这是上面条件判断的否定分支。如果status大于等于0，表示稳定性检测成功，那么就将status赋值给portstatus。
总的来说，这段代码的作用是处理USB端口的连接和使能状态发生变化的情况，并进行稳定性检测。如果稳定性检测失败，那么就清除端口的连接状态，并将端口标记为不可靠；如果稳定性检测成功，那么就更新端口的状态。
2.4.1 hub_port_debounce()函数
路径：drivers\usb\core\hub.h
static inline int hub_port_debounce_be_stable(struct usb_hub *hub,
int port1)
{
return hub_port_debounce(hub, port1, false);
}
int hub_port_debounce(struct usb_hub *hub, int port1, bool must_be_connected)
{
int ret;
u16 portchange, portstatus;
unsigned connection = 0xffff;
int total_time, stable_time = 0;
struct usb_port *port_dev = hub->ports[port1 - 1];
for (total_time = 0; ; total_time += HUB_DEBOUNCE_STEP) {
ret = usb_hub_port_status(hub, port1, &portstatus, &portchange);
if (ret < 0)
return ret;
if (!(portchange & USB_PORT_STAT_C_CONNECTION) &&
(portstatus & USB_PORT_STAT_CONNECTION) == connection) {
if (!must_be_connected ||
(connection == USB_PORT_STAT_CONNECTION))
stable_time += HUB_DEBOUNCE_STEP;
if (stable_time >= HUB_DEBOUNCE_STABLE)
break;
} else {
stable_time = 0;
connection = portstatus & USB_PORT_STAT_CONNECTION;
}
if (portchange & USB_PORT_STAT_C_CONNECTION) {
usb_clear_port_feature(hub->hdev, port1,
USB_PORT_FEAT_C_CONNECTION);
}
if (total_time >= HUB_DEBOUNCE_TIMEOUT)
break;
msleep(HUB_DEBOUNCE_STEP);
}
dev_dbg(&port_dev->dev, "debounce total %dms stable %dms status 0x%x\n",
total_time, stable_time, portstatus);
if (stable_time < HUB_DEBOUNCE_STABLE)
return -ETIMEDOUT;
return portstatus;
}
主要用于处理USB端口的稳定性检测。
int hub_port_debounce(struct usb_hub *hub, int port1, bool must_be_connected) {…}：定义了一个名为hub_port_debounce的函数，接收三个参数：一个指向USB集线器的指针hub，一个整数port1表示端口号，一个布尔值must_be_connected表示端口是否必须连接。
int ret; u16 portchange, portstatus; unsigned connection = 0xffff; int total_time, stable_time = 0; struct usb_port *port_dev = hub->ports[port1 - 1];：定义了一些局部变量，包括ret用于存储返回值，portchange和portstatus用于存储端口的状态改变和状态，connection用于存储连接状态，total_time和stable_time用于计时，port_dev用于存储端口设备。
for (total_time = 0; ; total_time += HUB_DEBOUNCE_STEP) {…}：这是一个无限循环，每次循环都会增加total_time的值。
ret = usb_hub_port_status(hub, port1, &portstatus, &portchange);：调用usb_hub_port_status函数，获取端口的状态和状态改变，然后将结果赋值给ret。
if (ret < 0) return ret;：如果ret小于0，表示获取状态失败，那么就返回ret。
if (!(portchange & USB_PORT_STAT_C_CONNECTION) && (portstatus & USB_PORT_STAT_CONNECTION) == connection) {…}：这是一个条件判断。如果端口的状态没有改变，并且端口的连接状态等于connection，那么就执行大括号中的代码。
if (portchange & USB_PORT_STAT_C_CONNECTION) {…}：这是一个条件判断。如果端口的状态改变了，那么就执行大括号中的代码。
if (total_time >= HUB_DEBOUNCE_TIMEOUT) break;：如果总时间超过了超时时间，那么就跳出循环。
msleep(HUB_DEBOUNCE_STEP);：让当前进程睡眠一段时间。
if (stable_time < HUB_DEBOUNCE_STABLE) return -ETIMEDOUT;：如果稳定时间小于稳定阈值，那么就返回-ETIMEDOUT。
return portstatus;：返回端口的状态。
总的来说，这个函数的作用是处理USB端口的稳定性检测。它会检测端口的连接状态，如果连接状态持续稳定一段时间，那么就返回端口的状态；如果连接状态持续不稳定，那么就返回超时错误。
2.5 第46-61行：处理USB端口连接稳定性检测失败
第46-61行：主要作用是在USB端口连接稳定性检测失败、没有设备连接或者设备被"移除"时，进行一些处理。
if (!(portstatus & USB_PORT_STAT_CONNECTION) || test_bit(port1, hub->removed_bits)) {…}：这是一个条件判断。如果端口的状态portstatus中没有设置USB_PORT_STAT_CONNECTION标志位，或者端口号port1在hub->removed_bits中被标记为"移除"，那么就执行大括号中的代码。
if (hub_is_port_power_switchable(hub) && !usb_port_is_power_on(hub, portstatus) && !port_dev->port_owner) set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);：这是一个嵌套的条件判断。如果端口的电源是可以切换的，且端口的电源没有打开，且端口没有被其他设备占用，那么就调用set_port_feature函数，设置端口的电源特性。
if (portstatus & USB_PORT_STAT_ENABLE) goto done;：这是一个嵌套的条件判断。如果端口的状态portstatus中设置了USB_PORT_STAT_ENABLE标志位，那么就跳转到done标签。
return;：返回，结束函数。
总的来说，这段代码的作用是在USB端口连接稳定性检测失败、没有设备连接或者设备被"移除"时，进行一些处理，包括可能的电源恢复和跳过后续的处理。
2.6 第62-65行：设置单位负载（unit load）的值
第62-65行：主要作用是根据USB集线器（hub）的速度等级，设置单位负载（unit load）的值。
if (hub_is_superspeed(hub->hdev))：这是一个条件判断。如果hub->hdev（即，hub的设备）是超高速（superspeed，即USB 3.0或更高版本），那么就执行大括号中的代码。
unit_load = 150;：将unit_load设置为150。这是因为在USB 3.0及更高版本中，一个USB端口的单位负载是150mA。
else：这是上面条件判断的否定分支。如果hub->hdev不是超高速，那么就执行大括号中的代码。
unit_load = 100;：将unit_load设置为100。这是因为在USB 2.0及更低版本中，一个USB端口的单位负载是100mA。
总的来说，这段代码的作用是根据USB集线器的速度等级，设置单位负载的值。这对于后续的电源管理和设备枚举等操作是必要的。
2.7 第69行：
第69行：是一个for循环的开始，用于尝试初始化USB端口。
for (i = 0; i < PORT_INIT_TRIES; i++) {…}：这是一个for循环，循环变量是i，循环次数是PORT_INIT_TRIES。PORT_INIT_TRIES是一个预定义的常量，表示初始化尝试的次数。
在这个循环中，会执行大括号里的代码，这部分代码通常是对USB端口进行初始化的操作，包括重置端口、获取设备描述符等。如果在尝试过程中发生错误，可能会进行错误处理，如禁用端口、释放设备等。
总的来说，这段代码的作用是尝试初始化USB端口，确保新连接的设备能够正常工作。
2.8 第70-73行：检测是否停止初始化
第70-73行：主要作用是在尝试初始化USB端口时，如果hub_port_stop_enumerate函数返回真，那么就停止初始化，并设置错误状态。
if (hub_port_stop_enumerate(hub, port1, i)) {…}：这是一个条件判断。如果hub_port_stop_enumerate函数返回真，那么就执行大括号中的代码。hub_port_stop_enumerate函数的作用通常是检查USB端口的初始化是否应该停止，它的参数是hub、端口号和当前的尝试次数。
status = -ENODEV;：将status设置为-ENODEV。-ENODEV是一个错误码，表示没有这样的设备，用于表示设备初始化失败。
break;：跳出循环。因为这段代码是在一个for循环中，所以break语句会结束这个循环。
总的来说，这段代码的作用是在尝试初始化USB端口时，如果hub_port_stop_enumerate函数返回真，那么就停止初始化，并设置错误状态。这是在处理USB端口连接事件时，对设备初始化过程的一个错误处理。
2.8.1 hub_port_stop_enumerate()函数
static bool hub_port_stop_enumerate(struct usb_hub *hub, int port1, int retries)
{
struct usb_port *port_dev = hub->ports[port1 - 1];
if (port_dev->early_stop) {
if (port_dev->ignore_event)
return true;
/*
* We want unsuccessful attempts to fail quickly.
* Since some devices may need one failure during
* port initialization, we allow two tries but no
* more.
*/
if (retries < 2)
return false;
port_dev->ignore_event = 1;
} else
port_dev->ignore_event = 0;
return port_dev->ignore_event;
}
这个函数的作用是检查USB端口的初始化是否应该停止。如果端口被标记为early_stop，并且重试次数大于等于2，那么就停止初始化；否则，就继续初始化。
2.9 第75-77行：锁定USB端口和主控制器设备的互斥锁保护并发访问
第75-77行：主要作用是锁定USB端口和主控制器设备的互斥锁，以保护对它们的并发访问。
usb_lock_port(port_dev);：调用usb_lock_port函数，锁定port_dev表示的USB端口。这是为了防止在初始化端口和设备时，其他线程同时对端口进行修改。
mutex_lock(hcd->address0_mutex);：调用mutex_lock函数，锁定hcd->address0_mutex表示的互斥锁。hcd是主控制器设备，address0_mutex是一个互斥锁，用于保护对地址0的访问。在USB中，地址0是默认的设备地址，所有新连接的设备都会首先被分配到这个地址。
retry_locked = true;：将retry_locked设置为真。这个变量通常用于标记是否已经获取了锁，如果已经获取了锁，那么在后续的错误处理中就需要释放这些锁。
总的来说，这段代码的作用是锁定USB端口和主控制器设备的互斥锁，以保护对它们的并发访问。这是在处理USB端口连接事件时，对设备初始化过程的一个常见步骤。
2.10 第81-88行：分配一个usb_device结构体
第81-88行：主要作用是为新连接的USB设备分配一个usb_device结构体，并进行错误处理。
udev = usb_alloc_dev(hdev, hdev->bus, port1);：调用usb_alloc_dev函数，为新连接的USB设备分配一个usb_device结构体，并将结果赋值给udev。usb_alloc_dev函数的参数是父设备（即，USB集线器设备hdev）、总线（即，hdev所在的总线）和端口号。
if (!udev) {…}：这是一个条件判断。如果udev为空（即，usb_alloc_dev函数返回NULL），表示分配usb_device结构体失败，那么就执行大括号中的代码。
dev_err(&port_dev->dev, “couldn’t allocate usb_device\n”);：调用dev_err函数，输出一条错误信息，表示无法分配usb_device。
mutex_unlock(hcd->address0_mutex);：调用mutex_unlock函数，解锁hcd->address0_mutex表示的互斥锁。这是因为在之前的代码中，我们锁定了这个互斥锁，所以在错误处理时需要解锁。
usb_unlock_port(port_dev);：调用usb_unlock_port函数，解锁port_dev表示的USB端口。这是因为在之前的代码中，我们锁定了这个端口，所以在错误处理时需要解锁。
goto done;：跳转到done标签。这通常表示跳出当前的函数或循环，结束后续的处理。
总的来说，这段代码的作用是为新连接的USB设备分配一个usb_device结构体，并进行错误处理。这是在处理USB端口连接事件时，对设备初始化过程的一个常见步骤。
2.11 第90-93行：设置新连接的USB设备基本属性
第90-93行：主要作用是设置新连接的USB设备的一些基本属性。
usb_set_device_state(udev, USB_STATE_POWERED);：调用usb_set_device_state函数，将设备udev的状态设置为USB_STATE_POWERED。这表示设备已经上电，但还没有被配置。
udev->bus_mA = hub->mA_per_port;：将设备udev的bus_mA属性设置为hub->mA_per_port。bus_mA表示设备从总线获取的电流，单位是毫安（mA）；mA_per_port表示集线器每个端口提供的电流。
udev->level = hdev->level + 1;：将设备udev的level属性设置为hdev->level + 1。level表示设备在USB设备树中的层级，hdev是父设备，所以udev的层级应该比hdev的层级高1。
udev->wusb = hub_is_wusb(hub);：将设备udev的wusb属性设置为hub_is_wusb(hub)的返回值。wusb表示设备是否支持无线USB；hub_is_wusb函数检查集线器是否支持无线USB。
总的来说，这段代码的作用是设置新连接的USB设备的一些基本属性，包括设备状态、电流、层级和无线USB支持等。这是在处理USB端口连接事件时，对设备初始化过程的一个常见步骤。
2.12 第96-99行：设置新连接的USB设备的速度等级
第96-99行：主要作用是设置新连接的USB设备的速度等级。
if (hub_is_superspeed(hub->hdev))：这是一个条件判断。如果hub->hdev（即，hub的设备）是超高速（superspeed，即USB 3.0或更高版本），那么就执行大括号中的代码。
udev->speed = USB_SPEED_SUPER;：将设备udev的速度等级设置为USB_SPEED_SUPER。这表示设备是超高速设备，即USB 3.0或更高版本。
else：这是上面条件判断的否定分支。如果hub->hdev不是超高速，那么就执行大括号中的代码。
udev->speed = USB_SPEED_UNKNOWN;：将设备udev的速度等级设置为USB_SPEED_UNKNOWN。这表示设备的速度等级未知。
总的来说，这段代码的作用是设置新连接的USB设备的速度等级。这对于后续的设备驱动程序加载和设备操作等是必要的。
2.13 第101-105行：为新连接的USB设备选择一个设备号
第101-105行：主要作用是为新连接的USB设备选择一个设备号，并进行错误处理。
choose_devnum(udev);：调用choose_devnum函数，为设备udev选择一个设备号。在USB系统中，设备号是用来唯一标识设备的一个数字。
if (udev->devnum <= 0) {…}：这是一个条件判断。如果设备udev的设备号小于等于0，表示选择设备号失败，那么就执行大括号中的代码。
status = -ENOTCONN;：将status设置为-ENOTCONN。-ENOTCONN是一个错误码，表示设备未连接，用于表示选择设备号失败。
goto loop;：跳转到loop标签。这通常表示跳出当前的函数或循环，结束后续的处理。
总的来说，这段代码的作用是为新连接的USB设备选择一个设备号，并进行错误处理。这是在处理USB端口连接事件时，对设备初始化过程的一个常见步骤。
2.13.1 choose_devnum()函数
static void choose_devnum(struct usb_device *udev)
{
int devnum;
struct usb_bus *bus = udev->bus;
/* be safe when more hub events are proceed in parallel */
mutex_lock(&bus->devnum_next_mutex);
if (udev->wusb) {
devnum = udev->portnum + 1;
BUG_ON(test_bit(devnum, bus->devmap.devicemap));
} else {
/* Try to allocate the next devnum beginning at
* bus->devnum_next. */
devnum = find_next_zero_bit(bus->devmap.devicemap, 128,
bus->devnum_next);
if (devnum >= 128)
devnum = find_next_zero_bit(bus->devmap.devicemap,
128, 1);
bus->devnum_next = (devnum >= 127 ? 1 : devnum + 1);
}
if (devnum < 128) {
set_bit(devnum, bus->devmap.devicemap);
udev->devnum = devnum;
}
mutex_unlock(&bus->devnum_next_mutex);
}
这个函数的作用是为新连接的USB设备选择一个设备号。如果设备支持无线USB，那么设备号就是端口号加1；否则，设备号就是总线设备映射中下一个为0的位。设备号用于唯一标识USB设备，对于设备的管理和操作非常重要。
2.14 第108-110行：初始化USB端口并获取设备描述符
第108-110行：主要作用是初始化USB端口并获取设备描述符，同时处理可能出现的错误。
status = hub_port_init(hub, udev, port1, i);：调用hub_port_init函数，对USB端口进行初始化并获取设备描述符，然后将返回的状态值赋给status。hub_port_init函数的参数包括USB集线器hub，USB设备udev，端口号port1和尝试次数i。
if (status < 0) {…}：这是一个条件判断。如果status小于0，表示hub_port_init函数执行失败，那么就执行大括号中的代码。
goto loop;：跳转到loop标签。这通常表示跳出当前的函数或循环，返回到某个特定的代码位置进行下一轮的循环或操作。
总的来说，这段代码的作用是初始化USB端口并获取设备描述符，同时处理可能出现的错误。这是在处理USB端口连接事件时，对设备初始化过程的一个常见步骤。
hub_port_init()函数的内容比较多，后续会单独一篇文章分析。
2.15 第112-114行：解锁
第112-114行：主要作用是解锁先前锁定的USB端口和主控制器设备的互斥锁，并将retry_locked设置为false。
2.16 第116-117行：
第116-117行：主要作用是在初始化USB设备时，如果设备的特性（quirks）中包含USB_QUIRK_DELAY_INIT，那么就延迟2秒（2000毫秒）。
if (udev->quirks & USB_QUIRK_DELAY_INIT) {…}：这是一个条件判断。如果设备udev的特性（quirks）中包含USB_QUIRK_DELAY_INIT，那么就执行大括号中的代码。在USB系统中，quirks是用来表示设备特性或者行为的一个位掩码，USB_QUIRK_DELAY_INIT是其中的一个位，表示设备在初始化时需要延迟。
msleep(2000);：调用msleep函数，延迟2000毫秒，即2秒。这是为了满足一些特殊设备在初始化时需要延迟一段时间的需求。
总的来说，这段代码的作用是在初始化USB设备时，如果设备的特性（quirks）中包含USB_QUIRK_DELAY_INIT，那么就延迟2秒（2000毫秒）。这是在处理USB设备初始化过程中，对设备特性的一个常见处理。
2.17 第125-149行：检查新连接的USB设备是否是集线器
第125-149行：主要作用是检查新连接的USB设备是否是一个连续的、由总线供电的集线器，并进行相应的处理。
if (udev->descriptor.bDeviceClass == USB_CLASS_HUB && udev->bus_mA <= unit_load) {…}：这是一个条件判断。如果设备udev是一个集线器，并且设备从总线获取的电流小于等于单位负载，那么就执行大括号中的代码。在USB系统中，连续的由总线供电的集线器可能会违反电压下降预算，因此需要进行特殊处理。
status = usb_get_std_status(udev, USB_RECIP_DEVICE, 0, &devstat);：调用usb_get_std_status函数，获取设备udev的状态，并将结果赋值给status。这是为了检查设备是否是自供电的。
if (status) {…}：这是一个条件判断。如果status不为0，表示获取设备状态失败，那么就执行大括号中的代码。
dev_dbg(&udev->dev, “get status %d ?\n”, status);：调用dev_dbg函数，输出一条调试信息，表示获取设备状态失败。
goto loop_disable;：跳转到loop_disable标签。这通常表示跳出当前的函数或循环，结束后续的处理。
if ((devstat & (1 << USB_DEVICE_SELF_POWERED)) == 0) {…}：这是一个条件判断。如果设备udev不是自供电的，那么就执行大括号中的代码。
dev_err(&udev->dev, “can’t connect bus-powered hub to this port\n”);：调用dev_err函数，输出一条错误信息，表示无法将由总线供电的集线器连接到这个端口。
if (hub->has_indicators) {…}：这是一个嵌套的条件判断。如果集线器hub有指示器，那么就执行大括号中的代码。
hub->indicator[port1-1] = INDICATOR_AMBER_BLINK;：将集线器hub的第port1-1个指示器的状态设置为INDICATOR_AMBER_BLINK，表示黄灯闪烁。
queue_delayed_work(system_power_efficient_wq, &hub->leds, 0);：调用queue_delayed_work函数，将hub->leds表示的工作项添加到system_power_efficient_wq表示的工作队列中，延迟0毫秒执行。这是为了更新集线器的LED指示器。
status = -ENOTCONN;：将status设置为-ENOTCONN。-ENOTCONN是一个错误码，表示设备未连接，用于表示无法将由总线供电的集线器连接到这个端口。
goto loop_disable;：跳转到loop_disable标签。这通常表示跳出当前的函数或循环，结束后续的处理。
总的来说，这段代码的作用是检查新连接的USB设备是否是一个连续的、由总线供电的集线器，并进行相应的处理。如果设备是由总线供电的集线器，并且不是自供电的，那么就输出错误信息，并更新集线器的LED指示器。
2.17.1 usb_get_status()函数
路径：include\linux\usb.h
static inline int usb_get_std_status(struct usb_device *dev,
int recip, int target, void *data)
{
return usb_get_status(dev, recip, USB_STATUS_TYPE_STANDARD, target,
data);
}
路径：drivers\usb\core\message.c
int usb_get_status(struct usb_device *dev, int recip, int type, int target,
void *data)
{
int ret;
void *status;
int length;
switch (type) {
case USB_STATUS_TYPE_STANDARD:
length = 2;
break;
case USB_STATUS_TYPE_PTM:
if (recip != USB_RECIP_DEVICE)
return -EINVAL;
length = 4;
break;
default:
return -EINVAL;
}
status = kmalloc(length, GFP_KERNEL);
if (!status)
return -ENOMEM;
ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
USB_REQ_GET_STATUS, USB_DIR_IN | recip, USB_STATUS_TYPE_STANDARD,
target, status, length, USB_CTRL_GET_TIMEOUT);
switch (ret) {
case 4:
if (type != USB_STATUS_TYPE_PTM) {
ret = -EIO;
break;
}
*(u32 *) data = le32_to_cpu(*(__le32 *) status);
ret = 0;
break;
case 2:
if (type != USB_STATUS_TYPE_STANDARD) {
ret = -EIO;
break;
}
*(u16 *) data = le16_to_cpu(*(__le16 *) status);
ret = 0;
break;
default:
ret = -EIO;
}
kfree(status);
return ret;
}
EXPORT_SYMBOL_GPL(usb_get_status);
这个函数的作用是获取USB设备的状态，包括设备是否自供电、是否启用了远程唤醒设施、批量或中断端点是否被阻塞等。这对于USB设备的管理和操作非常重要。
2.18 第152-155行：检查新连接的USB设备运行速度
第152-155行：主要作用是检查新连接的USB设备是否运行在比其实际能力更慢的速度上。
if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0200 && udev->speed == USB_SPEED_FULL && highspeed_hubs != 0) {…}：这是一个条件判断。如果设备udev的USB版本（由udev->descriptor.bcdUSB表示）大于等于2.0（即，设备支持高速USB）、设备的运行速度（由udev->speed表示）是全速（即，设备运行在全速模式下，而不是高速模式下）并且存在高速USB集线器（由highspeed_hubs表示），那么就执行大括号中的代码。
check_highspeed(hub, udev, port1);：调用check_highspeed函数，检查设备udev是否可以运行在高速模式下。check_highspeed函数的参数包括USB集线器hub，USB设备udev和端口号port1。
总的来说，这段代码的作用是检查新连接的USB设备是否运行在比其实际能力更慢的速度上。如果设备支持高速USB，但是运行在全速模式下，并且存在高速USB集线器，那么就需要检查设备是否可以运行在高速模式下。这是为了确保USB设备可以充分利用其性能，提供最佳的性能和用户体验。
2.19 第161-175行：将新连接的USB设备添加到其父集线器的子设备列表中
第161-175行：主要作用是将新连接的USB设备添加到其父集线器的子设备列表中，并进行错误处理。如果父设备已经被断开连接，那么就设置错误码并结束处理；否则，就将新设备添加到父设备的子设备列表中。这是在处理USB端口连接事件时，对设备初始化过程的一个常见步骤。
2.20 第178-191行：初始化新连接的USB设备
第178-191行：主要作用是初始化新连接的USB设备，并进行错误处理。
if (!status) {…}：这是一个条件判断。如果状态值status为0，表示之前的操作成功，那么就执行大括号中的代码。
status = usb_new_device(udev);：调用usb_new_device函数，初始化设备udev，并将返回的状态值赋给status。
if (status) {…}：这是一个嵌套的条件判断。如果status不为0，表示设备初始化失败，那么就执行大括号中的代码。
mutex_lock(&usb_port_peer_mutex);：调用mutex_lock函数，锁定usb_port_peer_mutex表示的互斥锁。usb_port_peer_mutex是一个全局的互斥锁，用于保护USB端口和其对等端口之间的关系。
spin_lock_irq(&device_state_lock);：调用spin_lock_irq函数，锁定device_state_lock表示的自旋锁，并禁用本地中断。device_state_lock是一个全局的自旋锁，用于保护设备状态的并发访问。
port_dev->child = NULL;：将port_dev的子设备设置为NULL。这表示设备udev没有成功初始化，因此从父设备的子设备列表中移除。
spin_unlock_irq(&device_state_lock);：调用spin_unlock_irq函数，解锁device_state_lock表示的自旋锁，并恢复本地中断。
mutex_unlock(&usb_port_peer_mutex);：调用mutex_unlock函数，解锁usb_port_peer_mutex表示的互斥锁。
else {…}：这是上面条件判断的否定分支。如果status为0，表示设备初始化成功，那么就执行大括号中的代码。
if (hcd->usb_phy && !hdev->parent) {…}：这是一个条件判断。如果主控制器设备hcd有USB PHY接口，并且设备hdev没有父设备（即，hdev是根集线器），那么就执行大括号中的代码。
usb_phy_notify_connect(hcd->usb_phy, udev->speed);：调用usb_phy_notify_connect函数，通知PHY接口设备已经连接，并传递设备的运行速度。
总的来说，这段代码的作用是初始化新连接的USB设备，并进行错误处理。如果设备初始化失败，那么就从父设备的子设备列表中移除；否则，如果设备是根集线器，那么就通知PHY接口设备已经连接。这是在处理USB端口连接事件时，对设备初始化过程的一个常见步骤。
usb_new_device()函数内容比较多，后面单独文章分析。
2.20.1 usb_phy_notify_connect()
路径：include\linux\usb\phy.h
static inline int
usb_phy_notify_connect(struct usb_phy *x, enum usb_device_speed speed)
{
if (x && x->notify_connect)
return x->notify_connect(x, speed);
else
return 0;
}
上述usb_phy 结构体中的notify_connect函数成员是由phy设备管理的。
在drivers\usb\phy\phy-mxs-usb.c 文件中：
static int mxs_phy_probe(struct platform_device *pdev) 函数内有：
mxs_phy->phy.notify_connect = mxs_phy_on_connect;
可知最终是调用mxs_phy_on_connect()函数实现notify的，函数内容如下：
路径：drivers\usb\phy\phy-mxs-usb.c
static int mxs_phy_on_connect(struct usb_phy *phy,
enum usb_device_speed speed)
{
dev_dbg(phy->dev, "%s device has connected\n",
(speed == USB_SPEED_HIGH) ? "HS" : "FS/LS");
if (speed == USB_SPEED_HIGH)
writel(BM_USBPHY_CTRL_ENHOSTDISCONDETECT,
phy->io_priv + HW_USBPHY_CTRL_SET);
return 0;
}
usb_phy_notify_disconnect()函数与 usb_phy_notify_connect的调用同理。
2.21 第193-200行：检查USB集线器的剩余电源
第193-200行：主要作用是检查USB集线器的剩余电源，并进行错误处理。
if (status) {…}：这是一个条件判断。如果状态值status不为0，表示之前的操作出错，那么就执行大括号中的代码。
goto loop_disable;：跳转到loop_disable标签。这通常表示跳出当前的函数或循环，返回到某个特定的代码位置进行下一轮的循环或操作。
status = hub_power_remaining(hub);：调用hub_power_remaining函数，获取集线器hub的剩余电源，并将结果赋值给status。
if (status) {…}：这是一个条件判断。如果状态值status不为0，表示集线器还有剩余电源，那么就执行大括号中的代码。
dev_dbg(hub->intfdev, “%dmA power budget left\n”, status);：调用dev_dbg函数，输出一条调试信息，表示集线器还有status毫安的剩余电源。
return;：结束函数的执行。
总的来说，这段代码的作用是检查USB集线器的剩余电源，并进行错误处理。如果之前的操作出错，那么就跳转到错误处理部分；否则，就获取集线器的剩余电源，并输出调试信息。这是在处理USB集线器电源管理时的一个常见步骤。
2.22 第202-203行：标签loop_disable
第202-203行：主要作用是在标签loop_disable:处调用hub_port_disable函数来禁用指定的USB集线器端口。
loop_disable:：这是一个标签，用于在代码中标记一个位置，以便在其他地方通过goto语句跳转到这里。
hub_port_disable(hub, port1, 1);：调用hub_port_disable函数，禁用集线器hub的端口port1。函数的第三个参数为1，表示在禁用端口后，还要重置端口。这通常用于错误处理，当端口出现错误时，需要禁用并重置端口以恢复其正常状态。
总的来说，这段代码的作用是在出现错误时，跳转到loop_disable标签处，禁用并重置出现错误的USB集线器端口。这是一个常见的错误处理步骤，用于恢复设备的正常状态。
2.22.1 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;
}
主要作用是定义一个函数hub_port_disable，该函数用于禁用指定的USB集线器端口。
static int hub_port_disable(struct usb_hub *hub, int port1, int set_state) {…}：定义了一个名为hub_port_disable的函数，接收一个指向usb_hub结构体的指针hub、一个整型参数port1和一个整型参数set_state作为参数。
struct usb_port *port_dev = hub->ports[port1 - 1];：从集线器hub的端口数组中获取第port1 - 1个端口，将其地址赋值给port_dev。
struct usb_device *hdev = hub->hdev;：获取集线器hub的设备，将其地址赋值给hdev。
int ret = 0;：定义一个整型变量ret，并初始化为0。ret通常用于表示函数或操作的返回值，0通常表示成功。
if (!hub->error) {…}：这是一个条件判断。如果集线器hub没有错误，那么就执行大括号中的代码。
if (hub_is_superspeed(hub->hdev)) {…}：这是一个嵌套的条件判断。如果设备hdev是一个超速设备，那么就执行大括号中的代码。
hub_usb3_port_prepare_disable(hub, port_dev);：调用hub_usb3_port_prepare_disable函数，准备禁用端口port_dev。
ret = hub_set_port_link_state(hub, port_dev->portnum, USB_SS_PORT_LS_U3);：调用hub_set_port_link_state函数，将端口port_dev的链接状态设置为USB_SS_PORT_LS_U3，并将返回的状态值赋值给ret。
else {…}：这是上面条件判断的否定分支。如果设备hdev不是一个超速设备，那么就执行大括号中的代码。
ret = usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_ENABLE);：调用usb_clear_port_feature函数，清除端口port1的使能特性，并将返回的状态值赋值给ret。
if (port_dev->child && set_state) {…}：这是一个条件判断。如果端口port_dev有子设备，并且set_state为真，那么就执行大括号中的代码。
usb_set_device_state(port_dev->child, USB_STATE_NOTATTACHED);：调用usb_set_device_state函数，将端口port_dev的子设备的状态设置为USB_STATE_NOTATTACHED。
if (ret && ret != -ENODEV) {…}：这是一个条件判断。如果ret不为0并且ret不等于-ENODEV，那么就执行大括号中的代码。
dev_err(&port_dev->dev, “cannot disable (err = %d)\n”, ret);：调用dev_err函数，输出一条错误信息，表示无法禁用端口，错误码为ret。
return ret;：返回ret。
总的来说，这个函数的作用是禁用指定的USB集线器端口。如果集线器没有错误，那么就根据设备的类型，选择不同的方式来禁用端口；如果端口有子设备，并且需要设置状态，那么就将子设备的状态设置为USB_STATE_NOTATTACHED；如果禁用端口失败，那么就输出错误信息。
2.23 第204-231行：处理USB设备的初始化和枚举过程中的错误和异常情况
第204-231行：主要用于处理USB设备的初始化和枚举过程中的错误和异常情况。
loop:：这是一个标签，用于在代码中标记一个位置，以便在其他地方通过goto语句跳转到这里。
usb_ep0_reinit(udev);：调用usb_ep0_reinit函数，重新初始化设备udev的端点0。端点0是USB设备的默认控制端点，用于处理设备级的命令和请求。
release_devnum(udev);：调用release_devnum函数，释放设备udev的设备号。设备号是用于唯一标识USB设备的一个编号。
hub_free_dev(udev);：调用hub_free_dev函数，释放设备udev。这通常表示设备udev已经被移除或者禁用。
if (retry_locked) {…}：这是一个条件判断。如果retry_locked为真，表示需要重试，那么就执行大括号中的代码。
mutex_unlock(hcd->address0_mutex);：调用mutex_unlock函数，解锁hcd->address0_mutex表示的互斥锁。hcd->address0_mutex是一个全局的互斥锁，用于保护设备地址的并发访问。
usb_unlock_port(port_dev);：调用usb_unlock_port函数，解锁端口port_dev。这通常表示端口port_dev已经完成了一个操作，可以进行下一个操作。
usb_put_dev(udev);：调用usb_put_dev函数，减少设备udev的引用计数。当设备的引用计数减少到0时，设备会被释放。
if ((status == -ENOTCONN) || (status == -ENOTSUPP)) {…}：这是一个条件判断。如果状态值status等于-ENOTCONN或者-ENOTSUPP，那么就执行大括号中的代码。
break;：跳出当前的循环。
if (i == (PORT_INIT_TRIES - 1) / 2) {…}：这是一个条件判断。如果当前是在尝试次数的一半时，那么就执行大括号中的代码。
dev_info(&port_dev->dev, “attempt power cycle\n”);：调用dev_info函数，输出一条信息，表示尝试进行电源循环。
usb_hub_set_port_power(hdev, hub, port1, false);：调用usb_hub_set_port_power函数，关闭集线器hub的端口port1的电源。
msleep(2 * hub_power_on_good_delay(hub));：调用msleep函数，暂停执行一段时间。暂停的时间是集线器hub的上电好延迟的两倍。
usb_hub_set_port_power(hdev, hub, port1, true);：调用usb_hub_set_port_power函数，打开集线器hub的端口port1的电源。
msleep(hub_power_on_good_delay(hub));：调用msleep函数，暂停执行一段时间。暂停的时间是集线器hub的上电好延迟。
if (hub->hdev->parent || !hcd->driver->port_handed_over || !(hcd->driver->port_handed_over)(hcd, port1)) {…}：这是一个条件判断。如果集线器hub有父设备，或者主控制器设备hcd的驱动没有port_handed_over函数，或者port_handed_over函数的返回值为假，那么就执行大括号中的代码。
if (status != -ENOTCONN && status != -ENODEV) {…}：这是一个嵌套的条件判断。如果状态值status不等于-ENOTCONN并且不等于-ENODEV，那么就执行大括号中的代码。
dev_err(&port_dev->dev, “unable to enumerate USB device\n”);：调用dev_err函数，输出一条错误信息，表示无法枚举USB设备。
总的来说，这段代码的作用是在USB设备的初始化和枚举过程中处理错误和异常情况。如果设备的初始化或枚举失败，那么就释放设备，解锁端口，减少设备的引用计数，并根据错误的类型进行相应的处理。如果设备的初始化或枚举多次失败，那么就尝试进行电源循环，以恢复设备的正常状态。
2.24 第233-238行：处理USB设备初始化和枚举过程结束后的操作
第7-10行：主要用于处理USB设备初始化和枚举过程结束后的一些操作。
done:：这是一个标签，用于在代码中标记一个位置，以便在其他地方通过goto语句跳转到这里。
hub_port_disable(hub, port1, 1);：调用hub_port_disable函数，禁用集线器hub的端口port1。函数的第三个参数为1，表示在禁用端口后，还要重置端口。这通常用于错误处理，当端口出现错误时，需要禁用并重置端口以恢复其正常状态。
if (hcd->driver->relinquish_port && !hub->hdev->parent) {…}：这是一个条件判断。如果主控制器设备hcd的驱动有relinquish_port函数，并且集线器hub没有父设备（即，hub是根集线器），那么就执行大括号中的代码。
if (status != -ENOTCONN && status != -ENODEV) {…}：这是一个嵌套的条件判断。如果状态值status不等于-ENOTCONN并且不等于-ENODEV，那么就执行大括号中的代码。
hcd->driver->relinquish_port(hcd, port1);：调用hcd->driver->relinquish_port函数，释放主控制器设备hcd的端口port1。这通常表示端口port1已经完成了一个操作，可以被其他设备或操作使用。
总的来说，这段代码的作用是在USB设备的初始化和枚举过程结束后处理一些清理工作，如禁用并重置出现错误的端口，释放已经完成操作的端口等。这些操作是为了确保USB设备和端口的正确状态，避免因错误或异常而导致的问题。
三、总结
以上是对USB port event下的端口链接发生变化处理函数hub_port_connect()的分析。后面将继续分析，hub_port_init () 和 usb_new_device()函数，前者是初始化一个port端口，后者则是在USB设备枚举后创建一个具体的USB设备 并添加到设备管理中。后面文章继续分析。
5299
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
