Linux那些事儿之我是Hub(20)八大重量级函数闪亮登场(四)

接下来我们来到了第四个函数,hub_port_init().这个函数和接下来要遇到的usb_new_device()是最重要的两个函数,也是相对复杂的函数.

   2096 /* Reset device, (re)assign address, get device descriptor.

   2097  * Device connection must be stable, no more debouncing needed.

   2098  * Returns device in USB_STATE_ADDRESS, except on error.

   2099  *

   2100  * If this is called for an already-existing device (as part of

   2101  * usb_reset_device), the caller must own the device lock.  For a

   2102  * newly detected device that is not accessible through any global

   2103  * pointers, it's not necessary to lock the device.

   2104  */

   2105 static int

   2106 hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,

   2107                 int retry_counter)

   2108 {

   2109         static DEFINE_MUTEX(usb_address0_mutex);

   2110

   2111         struct usb_device       *hdev = hub->hdev;

   2112         int                     i, j, retval;

   2113         unsigned                delay = HUB_SHORT_RESET_TIME;

   2114         enum usb_device_speed   oldspeed = udev->speed;

   2115         char                    *speed, *type;

   2116

   2117         /* root hub ports have a slightly longer reset period

   2118          * (from USB 2.0 spec, section 7.1.7.5)

   2119          */

   2120         if (!hdev->parent) {

   2121                 delay = HUB_ROOT_RESET_TIME;

   2122                 if (port1 == hdev->bus->otg_port)

   2123                         hdev->bus->b_hnp_enable = 0;

   2124         }

   2125

   2126         /* Some low speed devices have problems with the quick delay, so */

   2127         /*  be a bit pessimistic with those devices. RHbug #23670 */

   2128         if (oldspeed == USB_SPEED_LOW)

   2129                 delay = HUB_LONG_RESET_TIME;

   2130

   2131         mutex_lock(&usb_address0_mutex);

   2132

   2133         /* Reset the device; full speed may morph to high speed */

   2134         retval = hub_port_reset(hub, port1, udev, delay);

   2135         if (retval < 0)         /* error or disconnect */

   2136                 goto fail;

   2138         retval = -ENODEV;

   2139

   2140         if (oldspeed != USB_SPEED_UNKNOWN && oldspeed != udev->speed) {

   2141                 dev_dbg(&udev->dev, "device reset changed speed!/n");

   2142                 goto fail;

   2143         }

   2144         oldspeed = udev->speed;

   2145

   2146         /* USB 2.0 section 5.5.3 talks about ep0 maxpacket ...

   2147          * it's fixed size except for full speed devices.

   2148          * For Wireless USB devices, ep0 max packet is always 512 (tho

   2149          * reported as 0xff in the device descriptor). WUSB1.0[4.8.1].

   2150          */

   2151         switch (udev->speed) {

   2152         case USB_SPEED_VARIABLE:        /* fixed at 512 */

   2153                 udev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(512);

   2154                 break;

   2155         case USB_SPEED_HIGH:            /* fixed at 64 */

   2156                 udev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(64);

   2157                 break;

   2158         case USB_SPEED_FULL:            /* 8, 16, 32, or 64 */

   2159                 /* to determine the ep0 maxpacket size, try to read

   2160                  * the device descriptor to get bMaxPacketSize0 and

   2161                  * then correct our initial guess.

   2162                  */

   2163                 udev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(64);

   2164                 break;

   2165         case USB_SPEED_LOW:             /* fixed at 8 */

   2166                 udev->ep0.desc.wMaxPacketSize = __constant_cpu_to_le16(8);

   2167                 break;

   2168         default:

   2169                 goto fail;

   2170         }

   2171

   2172         type = "";

   2173         switch (udev->speed) {

   2174         case USB_SPEED_LOW:     speed = "low";  break;

   2175         case USB_SPEED_FULL:    speed = "full"; break;

   2176         case USB_SPEED_HIGH:    speed = "high"; break;

   2177         case USB_SPEED_VARIABLE:

   2178                                 speed = "variable";

   2179                                 type = "Wireless ";

   2180                                 break;

   2181         default:                speed = "?";    break;

   2182         }

   2183         dev_info (&udev->dev,

   2184                   "%s %s speed %sUSB device using %s and address %d/n",

   2185                   (udev->config) ? "reset" : "new", speed, type,

   2186                   udev->bus->controller->driver->name, udev->devnum);

   2187

   2188         /* Set up TT records, if needed  */

   2189         if (hdev->tt) {

   2190                 udev->tt = hdev->tt;

   2191                 udev->ttport = hdev->ttport;

   2192         } else if (udev->speed != USB_SPEED_HIGH

   2193                         && hdev->speed == USB_SPEED_HIGH) {

   2194                 udev->tt = &hub->tt;

   2195                 udev->ttport = port1;

   2196         }

   2197

   2198         /* Why interleave GET_DESCRIPTOR and SET_ADDRESS this way?

   2199          * Because device hardware and firmware is sometimes buggy in

   2200          * this area, and this is how Linux has done it for ages.

   2201          * Change it cautiously.

   2202          *

   2203          * NOTE:  If USE_NEW_SCHEME() is true we will start by issuing

   2204          * a 64-byte GET_DESCRIPTOR request.  This is what Windows does,

   2205          * so it may help with some non-standards-compliant devices.

   2206          * Otherwise we start with SET_ADDRESS and then try to read the

   2207          * first 8 bytes of the device descriptor to get the ep0 maxpacket

   2208          * value.

   2209          */

   2210         for (i = 0; i < GET_DESCRIPTOR_TRIES; (++i, msleep(100))) {

   2211                 if (USE_NEW_SCHEME(retry_counter)) {

   2212                         struct usb_device_descriptor *buf;

   2213                         int r = 0;

   2214

   2215 #define GET_DESCRIPTOR_BUFSIZE  64

   2216                         buf = kmalloc(GET_DESCRIPTOR_BUFSIZE, GFP_NOIO);

   2217                         if (!buf) {

   2218                                 retval = -ENOMEM;

   2219                                 continue;

   2220                         }

   2221

   2222                         /* Retry on all errors; some devices are flakey.

   2223                          * 255 is for WUSB devices, we actually need to use

   2224                          * 512 (WUSB1.0[4.8.1]).

   2225                          */

   2226                         for (j = 0; j < 3; ++j) {

   2227                                 buf->bMaxPacketSize0 = 0;

   2228                                 r = usb_control_msg(udev, usb_rcvaddr0pipe(),

   2229                                         USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,

   2230                                         USB_DT_DEVICE << 8, 0,

   2231                                         buf, GET_DESCRIPTOR_BUFSIZE,

   2232                                         USB_CTRL_GET_TIMEOUT);

   2233                                 switch (buf->bMaxPacketSize0) {

   2234                                 case 8: case 16: case 32: case 64: case 255:

   2235                                         if (buf->bDescriptorType ==

   2236                                                         USB_DT_DEVICE) {

   2237                                                 r = 0;

   2238                                                 break;

   2239                                         }

   2240                                         /* FALL THROUGH */

   2241                                 default:

   2242                                         if (r == 0)

   2243                                                 r = -EPROTO;

   2244                                         break;

   2245                                 }

   2246                                 if (r == 0)

   2247                                         break;

   2248                         }

   2249                         udev->descriptor.bMaxPacketSize0 =

   2250                                         buf->bMaxPacketSize0;

   2251                         kfree(buf);

   2252

   2253                         retval = hub_port_reset(hub, port1, udev, delay);

   2254                         if (retval < 0)         /* error or disconnect */

   2255                                 goto fail;

   2256                         if (oldspeed != udev->speed) {

   2257                                 dev_dbg(&udev->dev,

   2258                                         "device reset changed speed!/n");

   2259                                 retval = -ENODEV;

   2260                                 goto fail;

   2261                         }

   2262                         if (r) {

   2263                                 dev_err(&udev->dev, "device descriptor "

   2264                                                 "read/%s, error %d/n",

   2265                                                 "64", r);

   2266                                 retval = -EMSGSIZE;

   2267                                 continue;

   2268                         }

   2269 #undef GET_DESCRIPTOR_BUFSIZE

   2270                 }

   2271

   2272                 for (j = 0; j < SET_ADDRESS_TRIES; ++j) {

   2273                         retval = hub_set_address(udev);

   2274                         if (retval >= 0)

   2275                                 break;

   2276                         msleep(200);

   2277                 }

   2278                 if (retval < 0) {

   2279                         dev_err(&udev->dev,

   2280                                 "device not accepting address %d, error %d/n",

   2281                                 udev->devnum, retval);

   2282                         goto fail;

   2283                 }

   2284

   2285                 /* cope with hardware quirkiness:

   2286                  *  - let SET_ADDRESS settle, some device hardware wants it

   2287                  *  - read ep0 maxpacket even for high and low speed,

   2288                  */

   2289                 msleep(10);

   2290                 if (USE_NEW_SCHEME(retry_counter))

   2291                         break;

   2292

   2293                 retval = usb_get_device_descriptor(udev, 8);

   2294                 if (retval < 8) {

   2295                         dev_err(&udev->dev, "device descriptor "

   2296                                         "read/%s, error %d/n",

   2297                                         "8", retval);

   2298                         if (retval >= 0)

   2299                                 retval = -EMSGSIZE;

   2300                 } else {

   2301                         retval = 0;

   2302                         break;

   2303                 }

   2304         }

   2305         if (retval)

   2306                 goto fail;

   2307

   2308         i = udev->descriptor.bMaxPacketSize0 == 0xff?

   2309             512 : udev->descriptor.bMaxPacketSize0;

   2310         if (le16_to_cpu(udev->ep0.desc.wMaxPacketSize) != i) {

   2311                 if (udev->speed != USB_SPEED_FULL ||

   2312                                 !(i == 8 || i == 16 || i == 32 || i == 64)) {

   2313                         dev_err(&udev->dev, "ep0 maxpacket = %d/n", i);

   2314                         retval = -EMSGSIZE;

   2315                         goto fail;

   2316                 }

   2317                 dev_dbg(&udev->dev, "ep0 maxpacket = %d/n", i);

   2318                 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(i);

   2319                 ep0_reinit(udev);

   2320         }

   2321

   2322         retval = usb_get_device_descriptor(udev, USB_DT_DEVICE_SIZE);

   2323         if (retval < (signed)sizeof(udev->descriptor)) {

   2324                 dev_err(&udev->dev, "device descriptor read/%s, error %d/n",

   2325                         "all", retval);

   2326                 if (retval >= 0)

   2327                         retval = -ENOMSG;

   2328                 goto fail;

   2329         }

   2330

   2331         retval = 0;

   2332

   2333 fail:

   2334         if (retval)

   2335                 hub_port_disable(hub, port1, 0);

   2336         mutex_unlock(&usb_address0_mutex);

   2337         return retval;

   2338 }

像这种近300行的函数,这些年来,我竟也渐渐习惯了.我现在是以一种看文物的心态看这些变态的函数,竟也慢慢品出了一点周口店遗风.因为我明白,即便我像鲁迅先生那样呐喊,写代码的那些家伙也不会停下写这些函数的手.难怪江湖上称这些人的所作所为为行为艺术.

hub_port_init()这个函数的基本思想就是做初始化,首先是把一个设备reset,然后是分配地址.在然后是获得设备描述符.

首先DEFINE_MUTEX是来自于include/linux/mutex.h中的一个宏,用它可以定义一把互斥锁,在Linux内核中,其实是在2005年底才建立比较系统的完善的互斥锁机制,在那年冬天,北京的最后一场雪过后,来自RedHat公司的Ingo Molnar大侠大胆的提出了他所谓的Generic Mutex Subsystem,即通用的互斥锁机制.此前内核中很多地方使用的都是信号量,正如我们在2.6.10内核中usb-storage中所看到的那样,而当时间的箭头指向了2005年末的时候,区里(开源社区,下称区里)很多同志抱怨说信号量不灵,很多时候不好用,当然区里为这事展开了一场轰轰烈烈的讨论.老黑客Ingo Molnar受不了了,在一周之后,愤然提出要对内核进行一场大的革命,这次革命后来被称为一二一九运动.当时Ingo同志提出了诸多理由要求使用新的互斥锁机制,而不是过去普遍出现在内核中的信号量机制,比如新的机制占用更小的内存,代码更为紧凑,更快,更便于调试.在诸多优势的诱惑下,区里的群众将信将疑的便认可了这种做法.忽如一夜春风来,紧接着的几个月里,人民群众纷纷提交patch,把原来用信号量的地方都改成了互斥锁.而这种改变深入到Linux中usb子系统是始于2006年春天,农历二月二十二,Greg同志大旗一挥,将usb中的代码中绝大多数的信号量代码换成了互斥锁代码.所以到今天,您看2.6.22.1的代码中,整个usb子系统里几乎没有了down/up这一对函数的使用,取而代之的是mutex_lock()和mutex_unlock()函数对.而要初始化,只需像我们这里一样,DEFINE_MUTEX(name)即可.关于这个新的互斥锁的定义在include/linux/mutex.h中,而实现在kernel/mutex.c中.

Ok,让我们继续.hdev被定义用来记录hub所对应的那个struct usb_device,而delay记录延时,因为usb设备的reset工作不可能是瞬间的,通常会有一点点延时,这很容易理解,你的计算机永远不可能说你按一下reset键就立刻能够重起马上就能重新工作的,这里咱们首先给delay设置的初始值为10ms,即HUB_SHORT_RESET_TIME这个宏被定义为10ms.这个10ms的来源是usb spec 2.0中7.1.7.5节Reset Signaling里面说的,”The reset signaling must be driven for a minumum of 10ms”,这个10ms在usb spec中称之为T_DRST.一个Hub端口在reset之后将进入Enabled状态.

然后定义一个oldspeed用来记录设备在没有reset之前的速度.

2120行,只有root hub没有父亲,而usb spec 2.0里说得很清楚,”It is required that resets from root ports have a duration of at least 50ms”,这个50ms被称为T_DRSTR.即HUB_ROOT_RESET_TIME这个宏被定义为50ms.

2122和2123行是OTG相关的,HNP是OTG标准所支持的协议,HNP即Host Negotiation Protocol,坊间俗称主机通令协议.咱们既然不关注OTG,那么这里也就不做解释了.省得把问题复杂化了.当断不断,反受其乱. – 史记 春申君列传.

2128行,这两行代码来源于实践.实践表明,某些低速设备要求有比较高的延时才能完成好它们的reset,这很简单,286的机器重起肯定比P4的机器要慢.

好,调用mutex_lock获得互斥锁了,即表明下面这段代码一个时间只能被一个进程执行.

然后调用hub_port_reset().

   1509 static int hub_port_reset(struct usb_hub *hub, int port1,

   1510                                 struct usb_device *udev, unsigned int delay)

   1511 {

   1512         int i, status;

   1513

   1514         /* Reset the port */

   1515         for (i = 0; i < PORT_RESET_TRIES; i++) {

   1516                 status = set_port_feature(hub->hdev,

   1517                                 port1, USB_PORT_FEAT_RESET);

   1518                 if (status)

   1519                         dev_err(hub->intfdev,

   1520                                         "cannot reset port %d (err = %d)/n",

   1521                                         port1, status);

   1522                 else {

   1523                         status = hub_port_wait_reset(hub, port1, udev, delay);

   1524                         if (status && status != -ENOTCONN)

   1525                                 dev_dbg(hub->intfdev,

   1526                                                 "port_wait_reset: err = %d/n",

   1527                                                 status);

   1528                 }

   1529

   1530                 /* return on disconnect or reset */

   1531                 switch (status) {

   1532                 case 0:

   1533                         /* TRSTRCY = 10 ms; plus some extra */

   1534                         msleep(10 + 40);

   1535                         /* FALL THROUGH */

   1536                 case -ENOTCONN:

   1537                 case -ENODEV:

   1538                         clear_port_feature(hub->hdev,

   1539                                 port1, USB_PORT_FEAT_C_RESET);

   1540                         /* FIXME need disconnect() for NOTATTACHED device */

   1541                         usb_set_device_state(udev, status

   1542                                         ? USB_STATE_NOTATTACHED

   1543                                         : USB_STATE_DEFAULT);

   1544                         return status;

   1545                 }

   1546

   1547                 dev_dbg (hub->intfdev,

   1548                         "port %d not enabled, trying reset again.../n",

   1549                         port1);

   1550                 delay = HUB_LONG_RESET_TIME;

   1551         }

   1552

   1553         dev_err (hub->intfdev,

   1554                 "Cannot enable port %i.  Maybe the USB cable is bad?/n",

   1555                 port1);

   1556

   1557         return status;

   1558 }

事到如今,有些函数不讲也不行了.这就是set_port_feature.其实之前我们遇见过,只是因为当时属于可讲可不讲,所以就先跳过去了.但现在不讲不行了,我们前面讲过它的搭档clear_port_feature,所以我不讲你也应该知道set_port_feature()干嘛用的,很显然,一个是清楚feature,一个是设置feature.Linux中很多这种成对的函数,刚才讲的那个mutex_lock()和mutex_unlock()不也是这样么?其实这种思想是借鉴了我国的黄梅戏<<天仙配>>中所描绘的那种”你耕田来我织布,我挑水来你浇园,你我好比鸳鸯鸟,比翼双飞在人间”的纯朴的爱情观.

    172 /*

    173  * USB 2.0 spec Section 11.24.2.13

    174  */

    175 static int set_port_feature(struct usb_device *hdev, int port1, int feature)

    176 {

    177         return usb_control_msg(hdev, usb_sndctrlpipe(hdev, 0),

    178                 USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port1,

    179                 NULL, 0, 1000);

180 }

看明白了clear_port_feature()的一定不会觉得这个函数看不懂.发送一个控制请求,设置一个feature,咱们传递进来的feature是USB_PORT_FEAT_RESET,即对应于usb spec中的reset.发送好了之后就延时等待,调用hub_port_wait_reset():

   1457 static int hub_port_wait_reset(struct usb_hub *hub, int port1,

   1458                                 struct usb_device *udev, unsigned int delay)

   1459 {

   1460         int delay_time, ret;

   1461         u16 portstatus;

   1462         u16 portchange;

   1463

   1464         for (delay_time = 0;

   1465                         delay_time < HUB_RESET_TIMEOUT;

   1466                         delay_time += delay) {

   1467                 /* wait to give the device a chance to reset */

   1468                 msleep(delay);

   1469

   1470                 /* read and decode port status */

   1471                 ret = hub_port_status(hub, port1, &portstatus, &portchange);

   1472                 if (ret < 0)

   1473                         return ret;

   1474

   1475                 /* Device went away? */

   1476                 if (!(portstatus & USB_PORT_STAT_CONNECTION))

   1477                         return -ENOTCONN;

   1478

   1479                 /* bomb out completely if something weird happened */

   1480                 if ((portchange & USB_PORT_STAT_C_CONNECTION))

   1481                         return -EINVAL;

   1482

   1483                 /* if we`ve finished resetting, then break out of the loop */

   1484                 if (!(portstatus & USB_PORT_STAT_RESET) &&

   1485                     (portstatus & USB_PORT_STAT_ENABLE)) {

   1486                         if (hub_is_wusb(hub))

   1487                                 udev->speed = USB_SPEED_VARIABLE;

   1488                         else if (portstatus & USB_PORT_STAT_HIGH_SPEED)

   1489                                 udev->speed = USB_SPEED_HIGH;

   1490                         else if (portstatus & USB_PORT_STAT_LOW_SPEED)

   1491                                 udev->speed = USB_SPEED_LOW;

   1492                         else

   1493                                 udev->speed = USB_SPEED_FULL;

   1494                         return 0;

   1495                 }

   1496

   1497                 /* switch to the long delay after two short delay failures */

   1498                 if (delay_time >= 2 * HUB_SHORT_RESET_TIME)

   1499                         delay = HUB_LONG_RESET_TIME;

   1500

   1501                 dev_dbg (hub->intfdev,

   1502                         "port %d not reset yet, waiting %dms/n",

   1503                         port1, delay);

   1504         }

   1505

   1506         return -EBUSY;

   1507 }

这里HUB_RESET_TIMEOUT是设置的一个超时,这个宏的值为500毫秒,即如果reset了500毫秒还没好那么就返回错误值,朽木不可雕也.而循环的步长正是我们前面设置的那个delay.

msleep(delay)就是休眠delay毫秒.

休眠完了就读取端口的状态.hub_port_status()不用说了,咱们前面讲过了.获得端口状态.错误就返回错误码,正确就把信息记录在portstatus和portchange里.

1476行判断,如果在reset期间设备都被撤掉了,那就返回吧,甭浪费感情了.

1480行判断,如果又一次汇报说有设备插入,那就是见鬼了.返回错误立刻向上级汇报说人鬼情未了.

正如刚才说过的,reset真正完成以后,status就应该是enabled,所以1484和1485行的if如果满足就说明reset好了.

1486行这个if是判断这是否是一个无线Root hub,即既是Root Hub,又是无线hub,因为在struct usb_hcd中有一个成员unsigned wireless,这个flag标志了该主机控制器是Wireless的.我们刚才说过了,Wireless的话,speed就是那个USB_SPEED_VARIABLE.

否则如果portstatus和USB_PORT_STAT_HIGH_SPEED相与为1,则是高速设备,如果与USB_PORT_STAT_LOW_SPEED相与为1则是低速设备,剩下来的可能就是全速设备.到这里,这个hub_port_wait_reset就可以返回了,正常的返回0.总之,注意,经过这里udev的speed就被设置好了.

1497和1498行,走到这里就说明还没有reset好.如果已经过了2个HUB_SHORT_RESET_TIME,就把步长设置为HUB_LONG_RESET_TIME,即200ms,然后打印一条警告信息,继续循环,如果循环完全结束还不行,那就说明超时了,返回-EBUSY.

回到hub_port_reset中来,下面走到了1531行,一个switch,根据刚才的返回值做一次选择,如果是0,说明正常, 安全起见,索性再等50ms.如果是错误码,并且错误码表明设备不在了,则首先清掉reset这个feature,然后把这个为刚才这个设备申请的struct usb_device结构体的状态设置为USB_STATE_NOTATTACHED.并且返回status.如果你问那个USB_STATE_DEFAULT是怎么回事?那么说明你没有好好学谭浩强的那本经典教材.在switch里面,如果status为0,那么由于case 0那一部分后面break语句,所以case –ENOTCONN和case –ENODEV下面的那几句代码都会执行,即clear_port_feature是总会执行的,usb_set_device_state()也会执行,而对于status为0的情况,属于正常情况,从这时候开始,struct usb_device结构体的状态就将记录为USB_STATE_DEFAULT,即所谓的默认状态,然后返回值就是0.而对于端口reset,我们设置的重复次数是PORT_RESET_TRIES,它等于5,你当然可以把它改为1,没人拦住你.只要你对自己的设备够自信,一次reset就肯定成功.信自己,金莱克!

如果1553行还会执行,那么说明肯定出了大问题了,reset都没法进行,于是返回错误状态吧.

回到hub_init_port()中来,如果刚才失败了,就goto fail,否则也暂时将retval这个临时变量设置为-ENODEV,而2140行,如果oldspeed不是USB_SPEED_UNKNOWN,并且也不等于刚刚设置的这个speed,那么说明reset之前设备已经在工作了,而这次reset把设备原来的速度状态也给改变了.这是不合理的,必须结束函数,并且disable这个端口.于是goto fail,而在fail那边可以看到,由于retval不为0,所以调用hub_port_disable()关掉这个端口.然后释放互斥锁,并且返回错误代码.

2144行,如果不是刚才这种情况,那么令oldspeed等于现在这个udev->speed.

2151行开始,又是一个switch,感觉这一段代码的选择出现得太多了点,代码的选择倒是简单,可是人,作为微小而孤独的个体,在人生的选择题前,则总会无可避免地徘徊起来.在一个又一个渡口上,在一次又一次险象中,我们究竟能选择什么,该选择什么?

其实这里是设置一个初始值,我们曾经介绍过ep0.ep0.desc.wMaxPacketSizep0.desc.wMaxPacketSize用来记录端点0的单个包的最大传输size.对于无线设备,无线usb spec规定了,端点0的最大包size就是512,而对于高速设备,这个size也是usb spec规定好了,64bytes,而低速设备同样是usb spec规定好了,8bytes.唯一存在变数的是全速设备,它可能是8,可能是16,可能是32,也可能是64,对于这种设备,没有办法,只能通过读取设备描述符来获得了.也正是这个全速设备引发了我们前面讨论的那个两种策略的问题.不过那时候我们没有点明说是这场PK是因为全速设备引起的,因为那时候说还太早了,说了您也忘了,而现在看到了代码就不会忘了.正如我们说过的,Linux向Windows妥协了,这里Full Speed的设备,默认先把wMaxPacketSize设置为64,而不是以前的那种8.

2172至2186这些行,仅仅是为了打印一行调试信息,对于写代码的人来说,可能很有用,而对读代码的人来说,也许就没有任何意义了,正如对聋子而言,正版唱片CD的作用只是拿来当照脸的镜子.

Sep  9 11:32:49 localhost kernel: usb 4-5: new high speed USB device using ehci_hcd and address 3

Sep  9 11:32:52 localhost kernel: usb 2-1: new low speed USB device using uhci_hcd and address 3

比如在我的计算机里,就可以在/var/log/messages日志文件里看到上面这样的信息.ehci_hcd和uhci_hcd就是主机控制器的驱动程序.这个3就是设备的devnum.

2189行,不是switch又是if,除了判断还是判断,只不过刚才是选择,现在是如果,如果明天是世界末日,我就会去抢银行,可是既然明天是世界末日了,那要很多钱又能做什么呢?这里如果hdev->tt为真,则如何如何,否则,如果设备本身不是高速的,而hub是高速的,那么如何如何.tt我们介绍过,transaction translator,而ttport是struct usb_device中的一个成员,int ttport,这个ttport以后会被用到,tt也将在以后会被用到,暂时先不细说,到时候再回来看.

GET_DESCRIPTOR_TRIES等于2,这段代码的思想我们以前就讲过,USB_NEW_SCHEME(retry_counter),retry_counter就是hub_port_init()传递进来的最后一个参数,而我们给它的实参正是那个从0到SET_CONFIG_TRIES-1的那个i.假设我们什么也没有设置,都是使用默认值,那么use_both_schemes默认值为1,而old_scheme_first默认值为0,于是SET_CONFIG_TRIES为4,即i将从0变到3,而USB_NEW_SCHEME(i)将在i为0和1的时候为1,在i为2和3的时候为0.所以也就是说,先进行两次新的策略,如果不行就再进行两次旧的策略.所有这一切只有一个目的,就是为了获得设备的描述符.由于思想已经非常清楚,代码我们就不再一行一行讲了.尤其是那些错误判断的句子.

只是介绍一下其中调用的几个函数.对于新策略,首先定义一个struct usb_device_descriptor的指针buf,然后申请64个字节的空间,发送一个控制传输的请求,然后结束之后,察看buf->bMaxPackSize0,合理值只有8/16/32/64/512,这里255实际上是WUSB协议规定的,毕竟只有8位,最大就是255了,所以就用这个值来代表WUSB设备.实际上WUSB的大小是512.循环三次是保险起见.因为实践表明这类请求通常成功率很难达到100%.

然后2249行用udev->descriptor.bMaxPacketSize0来记录这个临时获得的值.然后buf的使命结束了,释放它的内存.

然后正如我们曾经分析的那样,把设备reset.

然后是设置地址.hub_set_address()

   2076 static int hub_set_address(struct usb_device *udev)

   2077 {

   2078         int retval;

   2079

   2080         if (udev->devnum == 0)

   2081                 return -EINVAL;

   2082         if (udev->state == USB_STATE_ADDRESS)

   2083                 return 0;

   2084         if (udev->state != USB_STATE_DEFAULT)

   2085                 return -EINVAL;

   2086         retval = usb_control_msg(udev, usb_sndaddr0pipe(),

   2087                 USB_REQ_SET_ADDRESS, 0, udev->devnum, 0,

   2088                 NULL, 0, USB_CTRL_SET_TIMEOUT);

   2089         if (retval == 0) {

   2090                 usb_set_device_state(udev, USB_STATE_ADDRESS);

   2091                 ep0_reinit(udev);

   2092         }

   2093         return retval;

   2094 }

和前面那个choose_address不同,choose_address是从软件意义上挑选一个地址.而这里要发送真正的请求,因为设置设备地址本身就是usb spec 2.0规定的标准的请求之一,这里我们用宏USB_REQ_SET_ADDRESS来代替,只有真正发送了请求之后硬件上才能真正通过这个地址进行通信.这里最关键的就是传递了udev->devnum,这正是我们前面选择的地址,这里赋给了wIndex,来自usb spec 2.0中图表说明了一切:

从此以后这个设备站起来了,并一举确立了它在usb江湖中的地位.

设好了地址之后,把设备的状态从开始的那个USB_STATE_DEFAULT变成了USB_STATE_ADDRESS,从此以后他就算是有户口的主了.在usb spec中,这一状态被称为Address state,我叫它有地址的状态.

然后调用了ep0_reinit().

   2066 static void ep0_reinit(struct usb_device *udev)

   2067 {

   2068         usb_disable_endpoint(udev, 0 + USB_DIR_IN);

   2069         usb_disable_endpoint(udev, 0 + USB_DIR_OUT);

   2070         udev->ep_in[0] = udev->ep_out[0] = &udev->ep0;

   2071 }

usb_disable_endpoint是usbcore提供的一个函数,具体到咱们这个端点,它会让ep_out[0]和ep_in[0]置为NULL.然后会取消掉任何挂在endpoint上的urb.再然后这里2070行再次把ep_in[0]和ep_out[0]指向udev->ep0.须知ep0是真正占内存的数据结构,而ep_in[0]和ep_out[0]只是指针,而在host controller驱动程序里将被用到的正是这两个指针数组.

回到hub_port_init中来,设置好了地址,然后2289行,先睡10ms,然后如果还是新策略,那么就可以结束了,因为该做的都做完了.如果是旧策略,那么执行到这里还刚上路呢,我们说过了,思路就是先获得设备描述符的前8个字节,然后从中得知udev->descriptor的bMaxPacketSize0,然后再次调用usb_get_device_descriptor完整的获得一次设备描述符.然后就ok了,到2336行,释放互斥锁,所谓的解铃还须系铃人.

至此,hub_port_init()就可以返回了.

声明一下 ,usb_get_device_descriptor() 是来自 drivers/usb/core/message.c 中的函数 , 由 usbcore 提供 , 我们这里就不细讲了 . 其作用是很明显的 , 获取设备描述符 .