Linux那些事儿之我是UHCI(18)Root Hub的控制传输(二)

医生,请把孩子取出来之后,顺便给我吸吸脂.

——广州一妇女在剖腹产手术前对医生说.

对于控制传输,rh_call_control会被调用.我也特别希望能有人给这个函数吸吸脂,我们的上下文是为了获取设备描述符,即当初那个usb_get_device_descriptor领着我们来到了这个函数,为了完成这件事情,实际上只需要很少的代码,但是rh_call_control这个函数涉及了所有的Root Hub相关的控制传输,以至于我们除了把孩子取出来之外,还不得不顺便看看其它的代码.当然了,既然是顺便,那么我们也就不会详细的去讲解每一行.这个函数定义于drivers/usb/core/hcd.c:

343 /* Root hub control transfers execute synchronously */

344 static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)

345 {

346 struct usb_ctrlrequest *cmd;

347 u16 typeReq, wValue, wIndex, wLength;

348 u8 *ubuf = urb->transfer_buffer;

349 u8 tbuf [sizeof (struct usb_hub_descriptor)]

350 __attribute__((aligned(4)));

351 const u8 *bufp = tbuf;

352 int len = 0;

353 int patch_wakeup = 0;

354 unsigned long flags;

355 int status = 0;

356 int n;

357

358 cmd = (struct usb_ctrlrequest *) urb->setup_packet;

359 typeReq = (cmd->bRequestType << 8) | cmd->bRequest;

360 wValue = le16_to_cpu (cmd->wValue);

361 wIndex = le16_to_cpu (cmd->wIndex);

362 wLength = le16_to_cpu (cmd->wLength);

363

364 if (wLength > urb->transfer_buffer_length)

365 goto error;

366

367 urb->actual_length = 0;

368 switch (typeReq) {

369

370 /* DEVICE REQUESTS */

371

372 /* The root hub's remote wakeup enable bit is implemented using

373 * driver model wakeup flags. If this system supports wakeup

374 * through USB, userspace may change the default "allow wakeup"

375 * policy through sysfs or these calls.

376 *

377 * Most root hubs support wakeup from downstream devices, for

378 * runtime power management (disabling USB clocks and reducing

379 * VBUS power usage). However, not all of them do so; silicon,

380 * board, and BIOS bugs here are not uncommon, so these can't

381 * be treated quite like external hubs.

382 *

383 * Likewise, not all root hubs will pass wakeup events upstream,

384 * to wake up the whole system. So don't assume root hub and

385 * controller capabilities are identical.

386 */

387

388 case DeviceRequest | USB_REQ_GET_STATUS:

389 tbuf [0] = (device_may_wakeup(&hcd->self.root_hub->dev)

390 << USB_DEVICE_REMOTE_WAKEUP)

391 | (1 << USB_DEVICE_SELF_POWERED);

392 tbuf [1] = 0;

393 len = 2;

394 break;

395 case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:

396 if (wValue == USB_DEVICE_REMOTE_WAKEUP)

397 device_set_wakeup_enable(&hcd->self.root_hub->dev, 0);

398 else

399 goto error;

400 break;

401 case DeviceOutRequest | USB_REQ_SET_FEATURE:

402 if (device_can_wakeup(&hcd->self.root_hub->dev)

403 && wValue == USB_DEVICE_REMOTE_WAKEUP)

404 device_set_wakeup_enable(&hcd->self.root_hub->dev, 1);

405 else

406 goto error;

407 break;

408 case DeviceRequest | USB_REQ_GET_CONFIGURATION:

409 tbuf [0] = 1;

410 len = 1;

411 /* FALLTHROUGH */

412 case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:

413 break;

414 case DeviceRequest | USB_REQ_GET_DESCRIPTOR:

415 switch (wValue & 0xff00) {

416 case USB_DT_DEVICE << 8:

417 if (hcd->driver->flags & HCD_USB2)

418 bufp = usb2_rh_dev_descriptor;

419 else if (hcd->driver->flags & HCD_USB11)

420 bufp = usb11_rh_dev_descriptor;

421 else

422 goto error;

423 len = 18;

424 break;

425 case USB_DT_CONFIG << 8:

426 if (hcd->driver->flags & HCD_USB2) {

427 bufp = hs_rh_config_descriptor;

428 len = sizeof hs_rh_config_descriptor;

429 } else {

430 bufp = fs_rh_config_descriptor;

431 len = sizeof fs_rh_config_descriptor;

432 }

433 if (device_can_wakeup(&hcd->self.root_hub->dev))

434 patch_wakeup = 1;

435 break;

436 case USB_DT_STRING << 8:

437 n = rh_string (wValue & 0xff, hcd, ubuf, wLength);

438 if (n < 0)

439 goto error;

440 urb->actual_length = n;

441 break;

442 default:

443 goto error;

444 }

445 break;

446 case DeviceRequest | USB_REQ_GET_INTERFACE:

447 tbuf [0] = 0;

448 len = 1;

449 /* FALLTHROUGH */

450 case DeviceOutRequest | USB_REQ_SET_INTERFACE:

451 break;

452 case DeviceOutRequest | USB_REQ_SET_ADDRESS:

453 // wValue == urb->dev->devaddr

454 dev_dbg (hcd->self.controller, "root hub device address %d/n",

455 wValue);

456 break;

457

458 /* INTERFACE REQUESTS (no defined feature/status flags) */

459

460 /* ENDPOINT REQUESTS */

461

462 case EndpointRequest | USB_REQ_GET_STATUS:

463 // ENDPOINT_HALT flag

464 tbuf [0] = 0;

465 tbuf [1] = 0;

466 len = 2;

467 /* FALLTHROUGH */

468 case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:

469 case EndpointOutRequest | USB_REQ_SET_FEATURE:

470 dev_dbg (hcd->self.controller, "no endpoint features yet/n");

471 break;

472

473 /* CLASS REQUESTS (and errors) */

474

475 default:

476 /* non-generic request */

477 switch (typeReq) {

478 case GetHubStatus:

479 case GetPortStatus:

480 len = 4;

481 break;

482 case GetHubDescriptor:

483 len = sizeof (struct usb_hub_descriptor);

484 break;

485 }

486 status = hcd->driver->hub_control (hcd,

487 typeReq, wValue, wIndex,

488 tbuf, wLength);

489 break;

490 error:

491 /* "protocol stall" on error */

492 status = -EPIPE;

493 }

494

495 if (status) {

496 len = 0;

497 if (status != -EPIPE) {

498 dev_dbg (hcd->self.controller,

499 "CTRL: TypeReq=0x%x val=0x%x "

500 "idx=0x%x len=%d ==> %d/n",

501 typeReq, wValue, wIndex,

502 wLength, status);

503 }

504 }

505 if (len) {

506 if (urb->transfer_buffer_length < len)

507 len = urb->transfer_buffer_length;

508 urb->actual_length = len;

509 // always USB_DIR_IN, toward host

510 memcpy (ubuf, bufp, len);

511

512 /* report whether RH hardware supports remote wakeup */

513 if (patch_wakeup &&

514 len > offsetof (struct usb_config_descriptor,

515 bmAttributes))

516 ((struct usb_config_descriptor *)ubuf)->bmAttributes

517 |= USB_CONFIG_ATT_WAKEUP;

518 }

519

520 /* any errors get returned through the urb completion */

521 local_irq_save (flags);

522 spin_lock (&urb->lock);

523 if (urb->status == -EINPROGRESS)

524 urb->status = status;

525 spin_unlock (&urb->lock);

526 usb_hcd_giveback_urb (hcd, urb);

527 local_irq_restore (flags);

528 return 0;

529 }

看到这样近200行的函数,真是有一种叫天天不灵叫地地不应的感觉.不幸中的万幸,这个函数的结构还是很清晰的.自上而下的看过来就可以了.

对于控制传输,首先要获得它的setup_packet,来自urb结构体,正如我们当初在usb-storage中看到的那样.这里把这个setup_packet赋给cmd指针.然后把其中的各个成员都给取出来,分别放在临时变量typeReq,wValue,wIndex,wLength中,然后来判断这个typeReq.

如果是设备请求并且方向是IN,而且是USB_REQ_GET_STATUS,则,设置len为2.

如果是设备请求并且方向是OUT,而且是USB_REQ_CLEAR_FEATURE,则如何如何.

如果是设备请求并且方向是OUT,而且是USB_REQ_SET_FEATURE,则如何如何.

如果是设备请求并且方向是IN,而且是USB_REQ_GET_CONFIGURATION,则设置len为1.

如果是设备请求并且方向是OUT,而且是USB_REQ_SET_CONFIGURATION,则啥也不做.

如果是设备请求并且方向是IN,而且是USB_REQ_GET_DESCRIPTOR,则继续判断,wValue到底是什么来决定究竟是要获得什么描述符.如果是USB_DT_DEVICE,则说明要获得的是设备描述符,这正是咱们的上下文,而整个这段函数中其它的内容就只相当于顺便看看.(咱们传递给usb_get_descriptor的第二个参数就是USB_DT_DEVICE,传递给usb_control_msg的第三个参数正是USB_REQ_GET_DESCRIPTOR.)如果是USB_DT_CONFIG,则说明要获得的是配置描述符,如果是USB_DT_STRING,则说明要获得的是字符串描述符.实际上,对于Root Hub来说,这些东西都是一样的,咱们在drivers/usb/core/hcd.c中都预先定义好了,usb2_rh_dev_descriptor是针对usb 2.0的,而usb11_rh_dev_descriptor是针对usb 1.1的,咱们的uhci driver里面设置了flags的HCD_USB11.

108 /*-------------------------------------------------------------------------*/

109

110 /*

111 * Sharable chunks of root hub code.

112 */

113

114 /*-------------------------------------------------------------------------*/

115

116 #define KERNEL_REL ((LINUX_VERSION_CODE >> 16) & 0x0ff)

117 #define KERNEL_VER ((LINUX_VERSION_CODE >> 8) & 0x0ff)

118

119 /* usb 2.0 root hub device descriptor */

120 static const u8 usb2_rh_dev_descriptor [18] = {

121 0x12, /* __u8 bLength; */

122 0x01, /* __u8 bDescriptorType; Device */

123 0x00, 0x02, /* __le16 bcdUSB; v2.0 */

124

125 0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */

126 0x00, /* __u8 bDeviceSubClass; */

127 0x01, /* __u8 bDeviceProtocol; [ usb 2.0 single TT ]*/

128 0x40, /* __u8 bMaxPacketSize0; 64 Bytes */

129

130 0x00, 0x00, /* __le16 idVendor; */

131 0x00, 0x00, /* __le16 idProduct; */

132 KERNEL_VER, KERNEL_REL, /* __le16 bcdDevice */

133

134 0x03, /* __u8 iManufacturer; */

135 0x02, /* __u8 iProduct; */

136 0x01, /* __u8 iSerialNumber; */

137 0x01 /* __u8 bNumConfigurations; */

138 };

139

140 /* no usb 2.0 root hub "device qualifier" descriptor: one speed only */

141

142 /* usb 1.1 root hub device descriptor */

143 static const u8 usb11_rh_dev_descriptor [18] = {

144 0x12, /* __u8 bLength; */

145 0x01, /* __u8 bDescriptorType; Device */

146 0x10, 0x01, /* __le16 bcdUSB; v1.1 */

147

148 0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */

149 0x00, /* __u8 bDeviceSubClass; */

150 0x00, /* __u8 bDeviceProtocol; [ low/full speeds only ] */

151 0x40, /* __u8 bMaxPacketSize0; 64 Bytes */

152

153 0x00, 0x00, /* __le16 idVendor; */

154 0x00, 0x00, /* __le16 idProduct; */

155 KERNEL_VER, KERNEL_REL, /* __le16 bcdDevice */

156

157 0x03, /* __u8 iManufacturer; */

158 0x02, /* __u8 iProduct; */

159 0x01, /* __u8 iSerialNumber; */

160 0x01 /* __u8 bNumConfigurations; */

161 };

162

163

164 /*-------------------------------------------------------------------------*/

165

166 /* Configuration descriptors for our root hubs */

167

168 static const u8 fs_rh_config_descriptor [] = {

169

170 /* one configuration */

171 0x09, /* __u8 bLength; */

172 0x02, /* __u8 bDescriptorType; Configuration */

173 0x19, 0x00, /* __le16 wTotalLength; */

174 0x01, /* __u8 bNumInterfaces; (1) */

175 0x01, /* __u8 bConfigurationValue; */

176 0x00, /* __u8 iConfiguration; */

177 0xc0, /* __u8 bmAttributes;

178 Bit 7: must be set,

179 6: Self-powered,

180 5: Remote wakeup,

181 4..0: resvd */

182 0x00, /* __u8 MaxPower; */

183

184 /* USB 1.1:

185 * USB 2.0, single TT organization (mandatory):

186 * one interface, protocol 0

187 *

188 * USB 2.0, multiple TT organization (optional):

189 * two interfaces, protocols 1 (like single TT)

190 * and 2 (multiple TT mode) ... config is

191 * sometimes settable

192 * NOT IMPLEMENTED

193 */

194

195 /* one interface */

196 0x09, /* __u8 if_bLength; */

197 0x04, /* __u8 if_bDescriptorType; Interface */

198 0x00, /* __u8 if_bInterfaceNumber; */

199 0x00, /* __u8 if_bAlternateSetting; */

200 0x01, /* __u8 if_bNumEndpoints; */

201 0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */

202 0x00, /* __u8 if_bInterfaceSubClass; */

203 0x00, /* __u8 if_bInterfaceProtocol; [usb1.1 or single tt] */

204 0x00, /* __u8 if_iInterface; */

205

206 /* one endpoint (status change endpoint) */

207 0x07, /* __u8 ep_bLength; */

208 0x05, /* __u8 ep_bDescriptorType; Endpoint */

209 0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */

210 0x03, /* __u8 ep_bmAttributes; Interrupt */

211 0x02, 0x00, /* __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) */

212 0xff /* __u8 ep_bInterval; (255ms -- usb 2.0 spec) */

213 };

214

215 static const u8 hs_rh_config_descriptor [] = {

216

217 /* one configuration */

218 0x09, /* __u8 bLength; */

219 0x02, /* __u8 bDescriptorType; Configuration */

220 0x19, 0x00, /* __le16 wTotalLength; */

221 0x01, /* __u8 bNumInterfaces; (1) */

222 0x01, /* __u8 bConfigurationValue; */

223 0x00, /* __u8 iConfiguration; */

224 0xc0, /* __u8 bmAttributes;

225 Bit 7: must be set,

226 6: Self-powered,

227 5: Remote wakeup,

228 4..0: resvd */

229 0x00, /* __u8 MaxPower; */

230

231 /* USB 1.1:

232 * USB 2.0, single TT organization (mandatory):

233 * one interface, protocol 0

234 *

235 * USB 2.0, multiple TT organization (optional):

236 * two interfaces, protocols 1 (like single TT)

237 * and 2 (multiple TT mode) ... config is

238 * sometimes settable

239 * NOT IMPLEMENTED

240 */

241

242 /* one interface */

243 0x09, /* __u8 if_bLength; */

244 0x04, /* __u8 if_bDescriptorType; Interface */

245 0x00, /* __u8 if_bInterfaceNumber; */

246 0x00, /* __u8 if_bAlternateSetting; */

247 0x01, /* __u8 if_bNumEndpoints; */

248 0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */

249 0x00, /* __u8 if_bInterfaceSubClass; */

250 0x00, /* __u8 if_bInterfaceProtocol; [usb1.1 or single tt] */

251 0x00, /* __u8 if_iInterface; */

252

253 /* one endpoint (status change endpoint) */

254 0x07, /* __u8 ep_bLength; */

255 0x05, /* __u8 ep_bDescriptorType; Endpoint */

256 0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */

257 0x03, /* __u8 ep_bmAttributes; Interrupt */

258 /* __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8)

259 * see hub.c:hub_configure() for details. */

260 (USB_MAXCHILDREN + 1 + 7) / 8, 0x00,

261 0x0c /* __u8 ep_bInterval; (256ms -- usb 2.0 spec) */

262 };

如果是设备请求且方向为IN,而且是USB_REQ_GET_INTERFACE,则设置len为1

如果是设备请求且方向为OUT,而且是USB_REQ_SET_INTERFACE,则如何如何.

如果是设备请求且方向为OUT,而且是USB_REQ_SET_ADDRESS,则如何如何.

如果是端点请求且方向为IN,而且是USB_REQ_GET_STATUS,则如何如何.

如果是端点请求且方向为OUT,而且是USB_REQ_CLEAR_FEATURE或者USB_REQ_SET_FEATURE,则如何如何.

以上这些设置,统统是和usb spec中规定的东西相匹配的.

如果是Hub特定的类请求,而且是GetHubStatus或者是GetPortStatus,则设置len为4.

如果是Hub特定的类请求,而且是GetHubDescriptor,则设置len为usb_hub_descriptor结构体的大小.

最后对于Hub特定的类请求需要调用主机控制器驱动程序的hub_control函数,对于uhci_driver来说,这个指针被赋值为uhci_hub_control,来自drivers/usb/host/uhci-hub.c:

238 /* size of returned buffer is part of USB spec */

239 static int uhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,

240 u16 wIndex, char *buf, u16 wLength)

241 {

242 struct uhci_hcd *uhci = hcd_to_uhci(hcd);

243 int status, lstatus, retval = 0, len = 0;

244 unsigned int port = wIndex - 1;

245 unsigned long port_addr = uhci->io_addr + USBPORTSC1 + 2 * port;

246 u16 wPortChange, wPortStatus;

247 unsigned long flags;

248

249 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags) || uhci->dead)

250 return -ETIMEDOUT;

251

252 spin_lock_irqsave(&uhci->lock, flags);

253 switch (typeReq) {

254

255 case GetHubStatus:

256 *(__le32 *)buf = cpu_to_le32(0);

257 OK(4); /* hub power */

258 case GetPortStatus:

259 if (port >= uhci->rh_numports)

260 goto err;

261

262 uhci_check_ports(uhci);

263 status = inw(port_addr);

264

265 /* Intel controllers report the OverCurrent bit active on.

266 * VIA controllers report it active off, so we'll adjust the

267 * bit value. (It's not standardized in the UHCI spec.)

268 */

269 if (to_pci_dev(hcd->self.controller)->vendor ==

270 PCI_VENDOR_ID_VIA)

271 status ^= USBPORTSC_OC;

272

273 /* UHCI doesn't support C_RESET (always false) */

274 wPortChange = lstatus = 0;

275 if (status & USBPORTSC_CSC)

276 wPortChange |= USB_PORT_STAT_C_CONNECTION;

277 if (status & USBPORTSC_PEC)

278 wPortChange |= USB_PORT_STAT_C_ENABLE;

279 if ((status & USBPORTSC_OCC) && !ignore_oc)

280 wPortChange |= USB_PORT_STAT_C_OVERCURRENT;

281

282 if (test_bit(port, &uhci->port_c_suspend)) {

283 wPortChange |= USB_PORT_STAT_C_SUSPEND;

284 lstatus |= 1;

285 }

286 if (test_bit(port, &uhci->resuming_ports))

287 lstatus |= 4;

288

289 /* UHCI has no power switching (always on) */

290 wPortStatus = USB_PORT_STAT_POWER;

291 if (status & USBPORTSC_CCS)

292 wPortStatus |= USB_PORT_STAT_CONNECTION;

293 if (status & USBPORTSC_PE) {

294 wPortStatus |= USB_PORT_STAT_ENABLE;

295 if (status & SUSPEND_BITS)

296 wPortStatus |= USB_PORT_STAT_SUSPEND;

297 }

298 if (status & USBPORTSC_OC)

299 wPortStatus |= USB_PORT_STAT_OVERCURRENT;

300 if (status & USBPORTSC_PR)

301 wPortStatus |= USB_PORT_STAT_RESET;

302 if (status & USBPORTSC_LSDA)

303 wPortStatus |= USB_PORT_STAT_LOW_SPEED;

304

305 if (wPortChange)

306 dev_dbg(uhci_dev(uhci), "port %d portsc %04x,%02x/n",

307 wIndex, status, lstatus);

308

309 *(__le16 *)buf = cpu_to_le16(wPortStatus);

310 *(__le16 *)(buf + 2) = cpu_to_le16(wPortChange);

311 OK(4);

312 case SetHubFeature: /* We don't implement these */

313 case ClearHubFeature:

314 switch (wValue) {

315 case C_HUB_OVER_CURRENT:

316 case C_HUB_LOCAL_POWER:

317 OK(0);

318 default:

319 goto err;

320 }

321 break;

322 case SetPortFeature:

323 if (port >= uhci->rh_numports)

324 goto err;

325

326 switch (wValue) {

327 case USB_PORT_FEAT_SUSPEND:

328 SET_RH_PORTSTAT(USBPORTSC_SUSP);

329 OK(0);

330 case USB_PORT_FEAT_RESET:

331 SET_RH_PORTSTAT(USBPORTSC_PR);

332

333 /* Reset terminates Resume signalling */

334 uhci_finish_suspend(uhci, port, port_addr);

335

336 /* USB v2.0 7.1.7.5 */

337 uhci->ports_timeout = jiffies + msecs_to_jiffies(50);

338 OK(0);

339 case USB_PORT_FEAT_POWER:

340 /* UHCI has no power switching */

341 OK(0);

342 default:

343 goto err;

344 }

345 break;

346 case ClearPortFeature:

347 if (port >= uhci->rh_numports)

348 goto err;

349

350 switch (wValue) {

351 case USB_PORT_FEAT_ENABLE:

352 CLR_RH_PORTSTAT(USBPORTSC_PE);

353

354 /* Disable terminates Resume signalling */

355 uhci_finish_suspend(uhci, port, port_addr);

356 OK(0);

357 case USB_PORT_FEAT_C_ENABLE:

358 CLR_RH_PORTSTAT(USBPORTSC_PEC);

359 OK(0);

360 case USB_PORT_FEAT_SUSPEND:

361 if (!(inw(port_addr) & USBPORTSC_SUSP)) {

362

363 /* Make certain the port isn't suspended */

364 uhci_finish_suspend(uhci, port, port_addr);

365 } else if (!test_and_set_bit(port,

366 &uhci->resuming_ports)) {

367 SET_RH_PORTSTAT(USBPORTSC_RD);

368

369 /* The controller won't allow RD to be set

370 * if the port is disabled. When this happens

371 * just skip the Resume signalling.

372 */

373 if (!(inw(port_addr) & USBPORTSC_RD))

374 uhci_finish_suspend(uhci, port,

375 port_addr);

376 else

377 /* USB v2.0 7.1.7.7 */

378 uhci->ports_timeout = jiffies +

379 msecs_to_jiffies(20);

380 }

381 OK(0);

382 case USB_PORT_FEAT_C_SUSPEND:

383 clear_bit(port, &uhci->port_c_suspend);

384 OK(0);

385 case USB_PORT_FEAT_POWER:

386 /* UHCI has no power switching */

387 goto err;

388 case USB_PORT_FEAT_C_CONNECTION:

389 CLR_RH_PORTSTAT(USBPORTSC_CSC);

390 OK(0);

391 case USB_PORT_FEAT_C_OVER_CURRENT:

392 CLR_RH_PORTSTAT(USBPORTSC_OCC);

393 OK(0);

394 case USB_PORT_FEAT_C_RESET:

395 /* this driver won't report these */

396 OK(0);

397 default:

398 goto err;

399 }

400 break;

401 case GetHubDescriptor:

402 len = min_t(unsigned int, sizeof(root_hub_hub_des), wLength);

403 memcpy(buf, root_hub_hub_des, len);

404 if (len > 2)

405 buf[2] = uhci->rh_numports;

406 OK(len);

407 default:

408 err:

409 retval = -EPIPE;

410 }

411 spin_unlock_irqrestore(&uhci->lock, flags);

412

413 return retval;

414 }

服了,彻底服了,变态的函数一个接着一个.莫非这群混蛋写一个200行的函数就跟我写一个20行的函数一样随便?

249行,struct usb_hcd结构体的成员unsigned long flags,咱们当初在usb_add_hcd中调用set_bit函数设置了这么一个flag,HCD_FLAG_HW_ACCESSIBLE,基本上这个flag在咱们的故事中是被设置了的.另外,struct uhci_hcd结构体有一个成员unsigned int dead,它如果为1就表明控制器挂了.

然后用一个switch来处理hub特定的类请求.OK居然也是一个宏,定义于drivers/usb/host/uhci-hub.c:

78 #define OK(x) len = (x); break

所以如果请求是GetHubStatus,则设置len为4.

如果请求是GetPortStatus,则调用uhci_check_ports.然后读端口寄存器.USBPORTSC_CSC表示端口连接有变化,USBPORTSC_PEC表示Port Enable有变化.USBPORTSC_OCC表示Over Current有变化,struct uhci_hcd的两个成员,port_c_suspend和resuming_ports都是电源管理相关的.

但无论如何,以上所做的这些都是为了获得两个东西,wPortStatus和wPortChange.以此来响应GetPortStatus这个请求.

接下来,SetHubFeature和ClearHubFeature咱们没啥好说的,不需要做什么.

但是SetPortFeature就有事情要做了.wValue表明具体是什么特征.

SET_RH_PORTSTAT这个宏就是专门用于设置Root Hub的端口特征的.

80 #define CLR_RH_PORTSTAT(x) /

81 status = inw(port_addr); /

82 status &= ~(RWC_BITS|WZ_BITS); /

83 status &= ~(x); /

84 status |= RWC_BITS & (x); /

85 outw(status, port_addr)

86

87 #define SET_RH_PORTSTAT(x) /

88 status = inw(port_addr); /

89 status |= (x); /

90 status &= ~(RWC_BITS|WZ_BITS); /

91 outw(status, port_addr)

对于USB_PORT_FEAT_RESET,还需要调用uhci_finish_suspend.

如果是USB_PORT_FEAT_POWER,则什么也不做,因为UHCI不吃这一套.

如果请求是ClearPortFeature,基本上也是一样的做法.除了调用的宏变成了CLR_RH_PORTSTAT.

如果请求是GetHubDescriptor,那就满足它呗.root_hub_hub_des是早就在drivers/usb/host/uhci-hub.c中定义好的:

15 static __u8 root_hub_hub_des[] =

16 {

17 0x09, /* __u8 bLength; */

18 0x29, /* __u8 bDescriptorType; Hub-descriptor */

19 0x02, /* __u8 bNbrPorts; */

20 0x0a, /* __u16 wHubCharacteristics; */

21 0x00, /* (per-port OC, no power switching) */

22 0x01, /* __u8 bPwrOn2pwrGood; 2ms */

23 0x00, /* __u8 bHubContrCurrent; 0 mA */

24 0x00, /* __u8 DeviceRemovable; *** 7 Ports max *** */

25 0xff /* __u8 PortPwrCtrlMask; *** 7 ports max *** */

26 };

回到rh_call_control,switch结束了,下面是判断status和len.

然后调用usb_hcd_giveback_urb().来自drivers/usb/core/hcd.c:

1373 /**

1374 * usb_hcd_giveback_urb - return URB from HCD to device driver

1375 * @hcd: host controller returning the URB

1376 * @urb: urb being returned to the USB device driver.

1377 * Context: in_interrupt()

1378 *

1379 * This hands the URB from HCD to its USB device driver, using its

1380 * completion function. The HCD has freed all per-urb resources

1381 * (and is done using urb->hcpriv). It also released all HCD locks;

1382 * the device driver won't cause problems if it frees, modifies,

1383 * or resubmits this URB.

1384 */

1385 void usb_hcd_giveback_urb (struct usb_hcd *hcd, struct urb *urb)

1386 {

1387 int at_root_hub;

1388

1389 at_root_hub = (urb->dev == hcd->self.root_hub);

1390 urb_unlink (urb);

1391

1392 /* lower level hcd code should use *_dma exclusively if the

1393 * host controller does DMA */

1394 if (hcd->self.uses_dma && !at_root_hub) {

1395 if (usb_pipecontrol (urb->pipe)

1396 && !(urb->transfer_flags & URB_NO_SETUP_DMA_MAP))

1397 dma_unmap_single (hcd->self.controller, urb->setup_dma,

1398 sizeof (struct usb_ctrlrequest),

1399 DMA_TO_DEVICE);

1400 if (urb->transfer_buffer_length != 0

1401 && !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP))

1402 dma_unmap_single (hcd->self.controller,

1403 urb->transfer_dma,

1404 urb->transfer_buffer_length,

1405 usb_pipein (urb->pipe)

1406 ? DMA_FROM_DEVICE

1407 : DMA_TO_DEVICE);

1408 }

1409

1410 usbmon_urb_complete (&hcd->self, urb);

1411 /* pass ownership to the completion handler */

1412 urb->complete (urb);

1413 atomic_dec (&urb->use_count);

1414 if (unlikely (urb->reject))

1415 wake_up (&usb_kill_urb_queue);

1416 usb_put_urb (urb);

1417 }

1418 EXPORT_SYMBOL (usb_hcd_giveback_urb);

这里最重要最有意义的一行当然就是1412行,调用urb的complete函数,这正是我们在usb-storage里期待的那个函数.从此rh_call_control函数也该返回了,以后设备驱动又获得了控制权.事实上令人欣喜的是对于Root Hub,1394行开始的这一段if是不会被执行的,因为at_root_hub显然是为真.不过就算这段要执行也没什么可怕的,无非就是把之前为这个urb建立的dma映射给取消掉.而另一方面,对于Root Hub来说,complete函数基本上是什么也不做,只不过是让咱们再次回到usb_start_wait_urb去,而控制传输需要的数据也已经copy到了urb->transfer_buffer中去了. 至此,Root Hub的控制传输就算结束了,即我们的usb_get_device_descriptor函数取得了空前绝后的圆满成功.