MdeModulePkg/Bus/Usb/UsbBusDxe/UsbEnumer.c

   1 /** @file
   2
   3     Usb bus enumeration support.
   4
   5 Copyright (c) 2007 - 2011, Intel Corporation. All rights reserved.<BR>
   6 This program and the accompanying materials
   7 are licensed and made available under the terms and conditions of the BSD License
   8 which accompanies this distribution.  The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "UsbBus.h"
  17
  18 /**
  19   Return the endpoint descriptor in this interface.
  20
  21   @param  UsbIf                 The interface to search in.
  22   @param  EpAddr                The address of the endpoint to return.
  23
  24   @return The endpoint descriptor or NULL.
  25
  26 **/
  27 USB_ENDPOINT_DESC *
  28 UsbGetEndpointDesc (
  29   IN USB_INTERFACE        *UsbIf,
  30   IN UINT8                EpAddr
  31   )
  32 {
  33   USB_ENDPOINT_DESC       *EpDesc;
  34   UINT8                   Index;
  35   UINT8                   NumEndpoints;
  36
  37   NumEndpoints = UsbIf->IfSetting->Desc.NumEndpoints;
  38
  39   for (Index = 0; Index < NumEndpoints; Index++) {
  40     EpDesc = UsbIf->IfSetting->Endpoints[Index];
  41
  42     if (EpDesc->Desc.EndpointAddress == EpAddr) {
  43       return EpDesc;
  44     }
  45   }
  46
  47   return NULL;
  48 }
  49
  50
  51 /**
  52   Free the resource used by USB interface.
  53
  54   @param  UsbIf                 The USB interface to free.
  55
  56 **/
  57 VOID
  58 UsbFreeInterface (
  59   IN USB_INTERFACE        *UsbIf
  60   )
  61 {
  62   UsbCloseHostProtoByChild (UsbIf->Device->Bus, UsbIf->Handle);
  63
  64   gBS->UninstallMultipleProtocolInterfaces (
  65          UsbIf->Handle,
  66          &gEfiDevicePathProtocolGuid,
  67          UsbIf->DevicePath,
  68          &gEfiUsbIoProtocolGuid,
  69          &UsbIf->UsbIo,
  70          NULL
  71          );
  72
  73   if (UsbIf->DevicePath != NULL) {
  74     FreePool (UsbIf->DevicePath);
  75   }
  76
  77   FreePool (UsbIf);
  78 }
  79
  80
  81 /**
  82   Create an interface for the descriptor IfDesc. Each
  83   device's configuration can have several interfaces.
  84
  85   @param  Device                The device has the interface descriptor.
  86   @param  IfDesc                The interface descriptor.
  87
  88   @return The created USB interface for the descriptor, or NULL.
  89
  90 **/
  91 USB_INTERFACE *
  92 UsbCreateInterface (
  93   IN USB_DEVICE           *Device,
  94   IN USB_INTERFACE_DESC   *IfDesc
  95   )
  96 {
  97   USB_DEVICE_PATH         UsbNode;
  98   USB_INTERFACE           *UsbIf;
  99   USB_INTERFACE           *HubIf;
 100   EFI_STATUS              Status;
 101
 102   UsbIf = AllocateZeroPool (sizeof (USB_INTERFACE));
 103
 104   if (UsbIf == NULL) {
 105     return NULL;
 106   }
 107
 108   UsbIf->Signature  = USB_INTERFACE_SIGNATURE;
 109   UsbIf->Device     = Device;
 110   UsbIf->IfDesc     = IfDesc;
 111   ASSERT (IfDesc->ActiveIndex < USB_MAX_INTERFACE_SETTING);
 112   UsbIf->IfSetting  = IfDesc->Settings[IfDesc->ActiveIndex];
 113
 114   CopyMem (
 115     &(UsbIf->UsbIo),
 116     &mUsbIoProtocol,
 117     sizeof (EFI_USB_IO_PROTOCOL)
 118     );
 119
 120   //
 121   // Install protocols for USBIO and device path
 122   //
 123   UsbNode.Header.Type       = MESSAGING_DEVICE_PATH;
 124   UsbNode.Header.SubType    = MSG_USB_DP;
 125   UsbNode.ParentPortNumber  = Device->ParentPort;
 126   UsbNode.InterfaceNumber   = UsbIf->IfSetting->Desc.InterfaceNumber;
 127
 128   SetDevicePathNodeLength (&UsbNode.Header, sizeof (UsbNode));
 129
 130   HubIf = Device->ParentIf;
 131   ASSERT (HubIf != NULL);
 132
 133   UsbIf->DevicePath = AppendDevicePathNode (HubIf->DevicePath, &UsbNode.Header);
 134
 135   if (UsbIf->DevicePath == NULL) {
 136     DEBUG ((EFI_D_ERROR, "UsbCreateInterface: failed to create device path\n"));
 137
 138     Status = EFI_OUT_OF_RESOURCES;
 139     goto ON_ERROR;
 140   }
 141
 142   Status = gBS->InstallMultipleProtocolInterfaces (
 143                   &UsbIf->Handle,
 144                   &gEfiDevicePathProtocolGuid,
 145                   UsbIf->DevicePath,
 146                   &gEfiUsbIoProtocolGuid,
 147                   &UsbIf->UsbIo,
 148                   NULL
 149                   );
 150
 151   if (EFI_ERROR (Status)) {
 152     DEBUG ((EFI_D_ERROR, "UsbCreateInterface: failed to install UsbIo - %r\n", Status));
 153     goto ON_ERROR;
 154   }
 155
 156   //
 157   // Open USB Host Controller Protocol by Child
 158   //
 159   Status = UsbOpenHostProtoByChild (Device->Bus, UsbIf->Handle);
 160
 161   if (EFI_ERROR (Status)) {
 162     gBS->UninstallMultipleProtocolInterfaces (
 163            &UsbIf->Handle,
 164            &gEfiDevicePathProtocolGuid,
 165            UsbIf->DevicePath,
 166            &gEfiUsbIoProtocolGuid,
 167            &UsbIf->UsbIo,
 168            NULL
 169            );
 170
 171     DEBUG ((EFI_D_ERROR, "UsbCreateInterface: failed to open host for child - %r\n", Status));
 172     goto ON_ERROR;
 173   }
 174
 175   return UsbIf;
 176
 177 ON_ERROR:
 178   if (UsbIf->DevicePath != NULL) {
 179     FreePool (UsbIf->DevicePath);
 180   }
 181
 182   FreePool (UsbIf);
 183   return NULL;
 184 }
 185
 186
 187 /**
 188   Free the resource used by this USB device.
 189
 190   @param  Device                The USB device to free.
 191
 192 **/
 193 VOID
 194 UsbFreeDevice (
 195   IN USB_DEVICE           *Device
 196   )
 197 {
 198   if (Device->DevDesc != NULL) {
 199     UsbFreeDevDesc (Device->DevDesc);
 200   }
 201
 202   gBS->FreePool (Device);
 203 }
 204
 205
 206 /**
 207   Create a device which is on the parent's ParentPort port.
 208
 209   @param  ParentIf              The parent HUB interface.
 210   @param  ParentPort            The port on the HUB this device is connected to.
 211
 212   @return Created USB device, Or NULL.
 213
 214 **/
 215 USB_DEVICE *
 216 UsbCreateDevice (
 217   IN USB_INTERFACE        *ParentIf,
 218   IN UINT8                ParentPort
 219   )
 220 {
 221   USB_DEVICE              *Device;
 222
 223   ASSERT (ParentIf != NULL);
 224
 225   Device = AllocateZeroPool (sizeof (USB_DEVICE));
 226
 227   if (Device == NULL) {
 228     return NULL;
 229   }
 230
 231   Device->Bus         = ParentIf->Device->Bus;
 232   Device->MaxPacket0  = 8;
 233   Device->ParentAddr  = ParentIf->Device->Address;
 234   Device->ParentIf    = ParentIf;
 235   Device->ParentPort  = ParentPort;
 236   Device->Tier        = (UINT8)(ParentIf->Device->Tier + 1);
 237   return Device;
 238 }
 239
 240
 241 /**
 242   Connect the USB interface with its driver. EFI USB bus will
 243   create a USB interface for each separate interface descriptor.
 244
 245   @param  UsbIf             The interface to connect driver to.
 246
 247   @return EFI_SUCCESS       Interface is managed by some driver.
 248   @return Others            Failed to locate a driver for this interface.
 249
 250 **/
 251 EFI_STATUS
 252 UsbConnectDriver (
 253   IN USB_INTERFACE        *UsbIf
 254   )
 255 {
 256   EFI_STATUS              Status;
 257   EFI_TPL                 OldTpl;
 258
 259   Status = EFI_SUCCESS;
 260
 261   //
 262   // Hub is maintained by the USB bus driver. Otherwise try to
 263   // connect drivers with this interface
 264   //
 265   if (UsbIsHubInterface (UsbIf)) {
 266     DEBUG ((EFI_D_INFO, "UsbConnectDriver: found a hub device\n"));
 267     Status = mUsbHubApi.Init (UsbIf);
 268
 269   } else {
 270     //
 271     // This function is called in both UsbIoControlTransfer and
 272     // the timer callback in hub enumeration. So, at least it is
 273     // called at TPL_CALLBACK. Some driver sitting on USB has
 274     // twisted TPL used. It should be no problem for us to connect
 275     // or disconnect at CALLBACK.
 276     //
 277
 278     //
 279     // Only recursively wanted usb child device
 280     //
 281     if (UsbBusIsWantedUsbIO (UsbIf->Device->Bus, UsbIf)) {
 282       OldTpl            = UsbGetCurrentTpl ();
 283       DEBUG ((EFI_D_INFO, "UsbConnectDriver: TPL before connect is %d, %p\n", (UINT32)OldTpl, UsbIf->Handle));
 284
 285       gBS->RestoreTPL (TPL_CALLBACK);
 286
 287       Status            = gBS->ConnectController (UsbIf->Handle, NULL, NULL, TRUE);
 288       UsbIf->IsManaged  = (BOOLEAN)!EFI_ERROR (Status);
 289
 290       DEBUG ((EFI_D_INFO, "UsbConnectDriver: TPL after connect is %d\n", (UINT32)UsbGetCurrentTpl()));
 291       ASSERT (UsbGetCurrentTpl () == TPL_CALLBACK);
 292
 293       gBS->RaiseTPL (OldTpl);
 294     }
 295   }
 296
 297   return Status;
 298 }
 299
 300
 301 /**
 302   Select an alternate setting for the interface.
 303   Each interface can have several mutually exclusive
 304   settings. Only one setting is active. It will
 305   also reset its endpoints' toggle to zero.
 306
 307   @param  IfDesc                The interface descriptor to set.
 308   @param  Alternate             The alternate setting number to locate.
 309
 310   @retval EFI_NOT_FOUND         There is no setting with this alternate index.
 311   @retval EFI_SUCCESS           The interface is set to Alternate setting.
 312
 313 **/
 314 EFI_STATUS
 315 UsbSelectSetting (
 316   IN USB_INTERFACE_DESC   *IfDesc,
 317   IN UINT8                Alternate
 318   )
 319 {
 320   USB_INTERFACE_SETTING   *Setting;
 321   UINT8                   Index;
 322
 323   //
 324   // Locate the active alternate setting
 325   //
 326   Setting = NULL;
 327
 328   for (Index = 0; Index < IfDesc->NumOfSetting; Index++) {
 329     ASSERT (Index < USB_MAX_INTERFACE_SETTING);
 330     Setting = IfDesc->Settings[Index];
 331
 332     if (Setting->Desc.AlternateSetting == Alternate) {
 333       break;
 334     }
 335   }
 336
 337   if (Index == IfDesc->NumOfSetting) {
 338     return EFI_NOT_FOUND;
 339   }
 340
 341   IfDesc->ActiveIndex = Index;
 342
 343   ASSERT (Setting != NULL);
 344   DEBUG ((EFI_D_INFO, "UsbSelectSetting: setting %d selected for interface %d\n",
 345               Alternate, Setting->Desc.InterfaceNumber));
 346
 347   //
 348   // Reset the endpoint toggle to zero
 349   //
 350   for (Index = 0; Index < Setting->Desc.NumEndpoints; Index++) {
 351     Setting->Endpoints[Index]->Toggle = 0;
 352   }
 353
 354   return EFI_SUCCESS;
 355 }
 356
 357
 358 /**
 359   Select a new configuration for the device. Each
 360   device may support several configurations.
 361
 362   @param  Device                The device to select configuration.
 363   @param  ConfigValue           The index of the configuration ( != 0).
 364
 365   @retval EFI_NOT_FOUND         There is no configuration with the index.
 366   @retval EFI_OUT_OF_RESOURCES  Failed to allocate resource.
 367   @retval EFI_SUCCESS           The configuration is selected.
 368
 369 **/
 370 EFI_STATUS
 371 UsbSelectConfig (
 372   IN USB_DEVICE           *Device,
 373   IN UINT8                ConfigValue
 374   )
 375 {
 376   USB_DEVICE_DESC         *DevDesc;
 377   USB_CONFIG_DESC         *ConfigDesc;
 378   USB_INTERFACE_DESC      *IfDesc;
 379   USB_INTERFACE           *UsbIf;
 380   EFI_STATUS              Status;
 381   UINT8                   Index;
 382
 383   //
 384   // Locate the active config, then set the device's pointer
 385   //
 386   DevDesc     = Device->DevDesc;
 387   ConfigDesc  = NULL;
 388
 389   for (Index = 0; Index < DevDesc->Desc.NumConfigurations; Index++) {
 390     ConfigDesc = DevDesc->Configs[Index];
 391
 392     if (ConfigDesc->Desc.ConfigurationValue == ConfigValue) {
 393       break;
 394     }
 395   }
 396
 397   if (Index == DevDesc->Desc.NumConfigurations) {
 398     return EFI_NOT_FOUND;
 399   }
 400
 401   Device->ActiveConfig = ConfigDesc;
 402
 403   DEBUG ((EFI_D_INFO, "UsbSelectConfig: config %d selected for device %d\n",
 404               ConfigValue, Device->Address));
 405
 406   //
 407   // Create interfaces for each USB interface descriptor.
 408   //
 409   for (Index = 0; Index < ConfigDesc->Desc.NumInterfaces; Index++) {
 410     //
 411     // First select the default interface setting, and reset
 412     // the endpoint toggles to zero for its endpoints.
 413     //
 414     IfDesc = ConfigDesc->Interfaces[Index];
 415     UsbSelectSetting (IfDesc, IfDesc->Settings[0]->Desc.AlternateSetting);
 416
 417     //
 418     // Create a USB_INTERFACE and install USB_IO and other protocols
 419     //
 420     UsbIf = UsbCreateInterface (Device, ConfigDesc->Interfaces[Index]);
 421
 422     if (UsbIf == NULL) {
 423       return EFI_OUT_OF_RESOURCES;
 424     }
 425
 426     ASSERT (Index < USB_MAX_INTERFACE);
 427     Device->Interfaces[Index] = UsbIf;
 428
 429     //
 430     // Connect the device to drivers, if it failed, ignore
 431     // the error. Don't let the unsupported interfaces to block
 432     // the supported interfaces.
 433     //
 434     Status = UsbConnectDriver (UsbIf);
 435
 436     if (EFI_ERROR (Status)) {
 437       DEBUG ((EFI_D_ERROR, "UsbSelectConfig: failed to connect driver %r, ignored\n", Status));
 438     }
 439   }
 440
 441   Device->NumOfInterface = Index;
 442
 443   return EFI_SUCCESS;
 444 }
 445
 446
 447 /**
 448   Disconnect the USB interface with its driver.
 449
 450   @param  UsbIf                 The interface to disconnect driver from.
 451
 452 **/
 453 VOID
 454 UsbDisconnectDriver (
 455   IN USB_INTERFACE        *UsbIf
 456   )
 457 {
 458   EFI_TPL                 OldTpl;
 459   EFI_STATUS              Status;
 460
 461   //
 462   // Release the hub if it's a hub controller, otherwise
 463   // disconnect the driver if it is managed by other drivers.
 464   //
 465   if (UsbIf->IsHub) {
 466     UsbIf->HubApi->Release (UsbIf);
 467
 468   } else if (UsbIf->IsManaged) {
 469     //
 470     // This function is called in both UsbIoControlTransfer and
 471     // the timer callback in hub enumeration. So, at least it is
 472     // called at TPL_CALLBACK. Some driver sitting on USB has
 473     // twisted TPL used. It should be no problem for us to connect
 474     // or disconnect at CALLBACK.
 475     //
 476     OldTpl           = UsbGetCurrentTpl ();
 477     DEBUG ((EFI_D_INFO, "UsbDisconnectDriver: old TPL is %d, %p\n", (UINT32)OldTpl, UsbIf->Handle));
 478
 479     gBS->RestoreTPL (TPL_CALLBACK);
 480
 481     Status = gBS->DisconnectController (UsbIf->Handle, NULL, NULL);
 482     UsbIf->IsManaged = FALSE;
 483
 484     DEBUG (( EFI_D_INFO, "UsbDisconnectDriver: TPL after disconnect is %d, %d\n", (UINT32)UsbGetCurrentTpl(), Status));
 485     ASSERT (UsbGetCurrentTpl () == TPL_CALLBACK);
 486
 487     gBS->RaiseTPL (OldTpl);
 488   }
 489 }
 490
 491
 492 /**
 493   Remove the current device configuration.
 494
 495   @param  Device                The USB device to remove configuration from.
 496
 497 **/
 498 VOID
 499 UsbRemoveConfig (
 500   IN USB_DEVICE           *Device
 501   )
 502 {
 503   USB_INTERFACE           *UsbIf;
 504   UINTN                   Index;
 505
 506   //
 507   // Remove each interface of the device
 508   //
 509   for (Index = 0; Index < Device->NumOfInterface; Index++) {
 510     ASSERT (Index < USB_MAX_INTERFACE);
 511     UsbIf = Device->Interfaces[Index];
 512
 513     if (UsbIf == NULL) {
 514       continue;
 515     }
 516
 517     UsbDisconnectDriver (UsbIf);
 518     UsbFreeInterface (UsbIf);
 519     Device->Interfaces[Index] = NULL;
 520   }
 521
 522   Device->ActiveConfig    = NULL;
 523   Device->NumOfInterface  = 0;
 524 }
 525
 526
 527 /**
 528   Remove the device and all its children from the bus.
 529
 530   @param  Device                The device to remove.
 531
 532   @retval EFI_SUCCESS           The device is removed.
 533
 534 **/
 535 EFI_STATUS
 536 UsbRemoveDevice (
 537   IN USB_DEVICE           *Device
 538   )
 539 {
 540   USB_BUS                 *Bus;
 541   USB_DEVICE              *Child;
 542   EFI_STATUS              Status;
 543   UINTN                   Index;
 544
 545   Bus = Device->Bus;
 546
 547   //
 548   // Remove all the devices on its downstream ports. Search from devices[1].
 549   // Devices[0] is the root hub.
 550   //
 551   for (Index = 1; Index < Bus->MaxDevices; Index++) {
 552     Child = Bus->Devices[Index];
 553
 554     if ((Child == NULL) || (Child->ParentAddr != Device->Address)) {
 555       continue;
 556     }
 557
 558     Status = UsbRemoveDevice (Child);
 559
 560     if (EFI_ERROR (Status)) {
 561       DEBUG ((EFI_D_ERROR, "UsbRemoveDevice: failed to remove child, ignore error\n"));
 562       Bus->Devices[Index] = NULL;
 563     }
 564   }
 565
 566   UsbRemoveConfig (Device);
 567
 568   DEBUG (( EFI_D_INFO, "UsbRemoveDevice: device %d removed\n", Device->Address));
 569
 570   ASSERT (Device->Address < Bus->MaxDevices);
 571   Bus->Devices[Device->Address] = NULL;
 572   UsbFreeDevice (Device);
 573
 574   return EFI_SUCCESS;
 575 }
 576
 577
 578 /**
 579   Find the child device on the hub's port.
 580
 581   @param  HubIf                 The hub interface.
 582   @param  Port                  The port of the hub this child is connected to.
 583
 584   @return The device on the hub's port, or NULL if there is none.
 585
 586 **/
 587 USB_DEVICE *
 588 UsbFindChild (
 589   IN USB_INTERFACE        *HubIf,
 590   IN UINT8                Port
 591   )
 592 {
 593   USB_DEVICE              *Device;
 594   USB_BUS                 *Bus;
 595   UINTN                   Index;
 596
 597   Bus = HubIf->Device->Bus;
 598
 599   //
 600   // Start checking from device 1, device 0 is the root hub
 601   //
 602   for (Index = 1; Index < Bus->MaxDevices; Index++) {
 603     Device = Bus->Devices[Index];
 604
 605     if ((Device != NULL) && (Device->ParentAddr == HubIf->Device->Address) &&
 606         (Device->ParentPort == Port)) {
 607
 608       return Device;
 609     }
 610   }
 611
 612   return NULL;
 613 }
 614
 615
 616 /**
 617   Enumerate and configure the new device on the port of this HUB interface.
 618
 619   @param  HubIf                 The HUB that has the device connected.
 620   @param  Port                  The port index of the hub (started with zero).
 621
 622   @retval EFI_SUCCESS           The device is enumerated (added or removed).
 623   @retval EFI_OUT_OF_RESOURCES  Failed to allocate resource for the device.
 624   @retval Others                Failed to enumerate the device.
 625
 626 **/
 627 EFI_STATUS
 628 UsbEnumerateNewDev (
 629   IN USB_INTERFACE        *HubIf,
 630   IN UINT8                Port
 631   )
 632 {
 633   USB_BUS                 *Bus;
 634   USB_HUB_API             *HubApi;
 635   USB_DEVICE              *Child;
 636   USB_DEVICE              *Parent;
 637   EFI_USB_PORT_STATUS     PortState;
 638   UINTN                   Address;
 639   UINT8                   Config;
 640   EFI_STATUS              Status;
 641
 642   Parent  = HubIf->Device;
 643   Bus     = Parent->Bus;
 644   HubApi  = HubIf->HubApi;
 645   Address = Bus->MaxDevices;
 646
 647   gBS->Stall (USB_WAIT_PORT_STABLE_STALL);
 648
 649   //
 650   // Hub resets the device for at least 10 milliseconds.
 651   // Host learns device speed. If device is of low/full speed
 652   // and the hub is a EHCI root hub, ResetPort will release
 653   // the device to its companion UHCI and return an error.
 654   //
 655   Status = HubApi->ResetPort (HubIf, Port);
 656
 657   if (EFI_ERROR (Status)) {
 658     DEBUG ((EFI_D_ERROR, "UsbEnumerateNewDev: failed to reset port %d - %r\n", Port, Status));
 659
 660     return Status;
 661   }
 662
 663   DEBUG (( EFI_D_INFO, "UsbEnumerateNewDev: hub port %d is reset\n", Port));
 664
 665   Child = UsbCreateDevice (HubIf, Port);
 666
 667   if (Child == NULL) {
 668     return EFI_OUT_OF_RESOURCES;
 669   }
 670
 671   //
 672   // OK, now identify the device speed. After reset, hub
 673   // fully knows the actual device speed.
 674   //
 675   Status = HubApi->GetPortStatus (HubIf, Port, &PortState);
 676
 677   if (EFI_ERROR (Status)) {
 678     DEBUG ((EFI_D_ERROR, "UsbEnumerateNewDev: failed to get speed of port %d\n", Port));
 679     goto ON_ERROR;
 680   }
 681
 682   if (!USB_BIT_IS_SET (PortState.PortStatus, USB_PORT_STAT_CONNECTION)) {
 683     DEBUG ((EFI_D_ERROR, "UsbEnumerateNewDev: No device presented at port %d\n", Port));
 684     goto ON_ERROR;
 685   } else if (USB_BIT_IS_SET (PortState.PortStatus, USB_PORT_STAT_SUPER_SPEED)){
 686     Child->Speed      = EFI_USB_SPEED_SUPER;
 687     Child->MaxPacket0 = 512;
 688   } else if (USB_BIT_IS_SET (PortState.PortStatus, USB_PORT_STAT_HIGH_SPEED)) {
 689     Child->Speed      = EFI_USB_SPEED_HIGH;
 690     Child->MaxPacket0 = 64;
 691   } else if (USB_BIT_IS_SET (PortState.PortStatus, USB_PORT_STAT_LOW_SPEED)) {
 692     Child->Speed      = EFI_USB_SPEED_LOW;
 693     Child->MaxPacket0 = 8;
 694   } else {
 695     Child->Speed      = EFI_USB_SPEED_FULL;
 696     Child->MaxPacket0 = 8;
 697   }
 698
 699   DEBUG (( EFI_D_INFO, "UsbEnumerateNewDev: device is of %d speed\n", Child->Speed));
 700
 701   if (Child->Speed != EFI_USB_SPEED_HIGH) {
 702     //
 703     // If the child isn't a high speed device, it is necessary to
 704     // set the transaction translator. Port TT is 1-based.
 705     // This is quite simple:
 706     //  1. if parent is of high speed, then parent is our translator
 707     //  2. otherwise use parent's translator.
 708     //
 709     if (Parent->Speed == EFI_USB_SPEED_HIGH) {
 710       Child->Translator.TranslatorHubAddress  = Parent->Address;
 711       Child->Translator.TranslatorPortNumber  = (UINT8) (Port + 1);
 712
 713     } else {
 714       Child->Translator = Parent->Translator;
 715     }
 716
 717     DEBUG (( EFI_D_INFO, "UsbEnumerateNewDev: device uses translator (%d, %d)\n",
 718                 Child->Translator.TranslatorHubAddress,
 719                 Child->Translator.TranslatorPortNumber));
 720   }
 721
 722   //
 723   // After port is reset, hub establishes a signal path between
 724   // the device and host (DEFALUT state). Device's registers are
 725   // reset, use default address 0 (host enumerates one device at
 726   // a time) , and ready to respond to control transfer at EP 0.
 727   //
 728
 729   //
 730   // Host assigns an address to the device. Device completes the
 731   // status stage with default address, then switches to new address.
 732   // ADDRESS state. Address zero is reserved for root hub.
 733   //
 734   ASSERT (Bus->MaxDevices <= 256);
 735   for (Address = 1; Address < Bus->MaxDevices; Address++) {
 736     if (Bus->Devices[Address] == NULL) {
 737       break;
 738     }
 739   }
 740
 741   if (Address >= Bus->MaxDevices) {
 742     DEBUG ((EFI_D_ERROR, "UsbEnumerateNewDev: address pool is full for port %d\n", Port));
 743
 744     Status = EFI_ACCESS_DENIED;
 745     goto ON_ERROR;
 746   }
 747
 748   Status                = UsbSetAddress (Child, (UINT8)Address);
 749   Child->Address        = (UINT8)Address;
 750   Bus->Devices[Address] = Child;
 751
 752   if (EFI_ERROR (Status)) {
 753     DEBUG ((EFI_D_ERROR, "UsbEnumerateNewDev: failed to set device address - %r\n", Status));
 754     goto ON_ERROR;
 755   }
 756
 757   gBS->Stall (USB_SET_DEVICE_ADDRESS_STALL);
 758
 759   DEBUG ((EFI_D_INFO, "UsbEnumerateNewDev: device is now ADDRESSED at %d\n", Address));
 760
 761   //
 762   // Host sends a Get_Descriptor request to learn the max packet
 763   // size of default pipe (only part of the device's descriptor).
 764   //
 765   Status = UsbGetMaxPacketSize0 (Child);
 766
 767   if (EFI_ERROR (Status)) {
 768     DEBUG ((EFI_D_ERROR, "UsbEnumerateNewDev: failed to get max packet for EP 0 - %r\n", Status));
 769     goto ON_ERROR;
 770   }
 771
 772   DEBUG (( EFI_D_INFO, "UsbEnumerateNewDev: max packet size for EP 0 is %d\n", Child->MaxPacket0));
 773
 774   //
 775   // Host learns about the device's abilities by requesting device's
 776   // entire descriptions.
 777   //
 778   Status = UsbBuildDescTable (Child);
 779
 780   if (EFI_ERROR (Status)) {
 781     DEBUG ((EFI_D_ERROR, "UsbEnumerateNewDev: failed to build descriptor table - %r\n", Status));
 782     goto ON_ERROR;
 783   }
 784
 785   //
 786   // Select a default configuration: UEFI must set the configuration
 787   // before the driver can connect to the device.
 788   //
 789   Config = Child->DevDesc->Configs[0]->Desc.ConfigurationValue;
 790   Status = UsbSetConfig (Child, Config);
 791
 792   if (EFI_ERROR (Status)) {
 793     DEBUG ((EFI_D_ERROR, "UsbEnumerateNewDev: failed to set configure %d - %r\n", Config, Status));
 794     goto ON_ERROR;
 795   }
 796
 797   DEBUG (( EFI_D_INFO, "UsbEnumerateNewDev: device %d is now in CONFIGED state\n", Address));
 798
 799   //
 800   // Host assigns and loads a device driver.
 801   //
 802   Status = UsbSelectConfig (Child, Config);
 803
 804   if (EFI_ERROR (Status)) {
 805     DEBUG ((EFI_D_ERROR, "UsbEnumerateNewDev: failed to create interfaces - %r\n", Status));
 806     goto ON_ERROR;
 807   }
 808
 809   return EFI_SUCCESS;
 810
 811 ON_ERROR:
 812   if (Address != Bus->MaxDevices) {
 813     Bus->Devices[Address] = NULL;
 814   }
 815
 816   if (Child != NULL) {
 817     UsbFreeDevice (Child);
 818   }
 819
 820   return Status;
 821 }
 822
 823
 824 /**
 825   Process the events on the port.
 826
 827   @param  HubIf                 The HUB that has the device connected.
 828   @param  Port                  The port index of the hub (started with zero).
 829
 830   @retval EFI_SUCCESS           The device is enumerated (added or removed).
 831   @retval EFI_OUT_OF_RESOURCES  Failed to allocate resource for the device.
 832   @retval Others                Failed to enumerate the device.
 833
 834 **/
 835 EFI_STATUS
 836 UsbEnumeratePort (
 837   IN USB_INTERFACE        *HubIf,
 838   IN UINT8                Port
 839   )
 840 {
 841   USB_HUB_API             *HubApi;
 842   USB_DEVICE              *Child;
 843   EFI_USB_PORT_STATUS     PortState;
 844   EFI_STATUS              Status;
 845
 846   Child   = NULL;
 847   HubApi  = HubIf->HubApi;
 848
 849   //
 850   // Host learns of the new device by polling the hub for port changes.
 851   //
 852   Status = HubApi->GetPortStatus (HubIf, Port, &PortState);
 853
 854   if (EFI_ERROR (Status)) {
 855     DEBUG ((EFI_D_ERROR, "UsbEnumeratePort: failed to get state of port %d\n", Port));
 856     return Status;
 857   }
 858
 859   //
 860   // Only handle connection/enable/overcurrent/reset change.
 861   // Usb super speed hub may report other changes, such as warm reset change. Ignore them.
 862   //
 863   if ((PortState.PortChangeStatus & (USB_PORT_STAT_C_CONNECTION | USB_PORT_STAT_C_ENABLE | USB_PORT_STAT_C_OVERCURRENT | USB_PORT_STAT_C_RESET)) == 0) {
 864     return EFI_SUCCESS;
 865   }
 866
 867   DEBUG (( EFI_D_INFO, "UsbEnumeratePort: port %d state - %02x, change - %02x on %p\n",
 868               Port, PortState.PortChangeStatus, PortState.PortStatus, HubIf));
 869
 870   //
 871   // This driver only process two kinds of events now: over current and
 872   // connect/disconnect. Other three events are: ENABLE, SUSPEND, RESET.
 873   // ENABLE/RESET is used to reset port. SUSPEND isn't supported.
 874   //
 875
 876   if (USB_BIT_IS_SET (PortState.PortChangeStatus, USB_PORT_STAT_C_OVERCURRENT)) {
 877
 878     if (USB_BIT_IS_SET (PortState.PortStatus, USB_PORT_STAT_OVERCURRENT)) {
 879       //
 880       // Case1:
 881       //   Both OverCurrent and OverCurrentChange set, means over current occurs,
 882       //   which probably is caused by short circuit. It has to wait system hardware
 883       //   to perform recovery.
 884       //
 885       DEBUG (( EFI_D_ERROR, "UsbEnumeratePort: Critical Over Current\n", Port));
 886       return EFI_DEVICE_ERROR;
 887
 888     }
 889     //
 890     // Case2:
 891     //   Only OverCurrentChange set, means system has been recoveried from
 892     //   over current. As a result, all ports are nearly power-off, so
 893     //   it's necessary to detach and enumerate all ports again.
 894     //
 895     DEBUG (( EFI_D_ERROR, "UsbEnumeratePort: 2.0 device Recovery Over Current\n", Port));
 896   }
 897
 898   if (USB_BIT_IS_SET (PortState.PortChangeStatus, USB_PORT_STAT_C_ENABLE)) {
 899     //
 900     // Case3:
 901     //   1.1 roothub port reg doesn't reflect over-current state, while its counterpart
 902     //   on 2.0 roothub does. When over-current has influence on 1.1 device, the port
 903     //   would be disabled, so it's also necessary to detach and enumerate again.
 904     //
 905     DEBUG (( EFI_D_ERROR, "UsbEnumeratePort: 1.1 device Recovery Over Current\n", Port));
 906   }
 907
 908   if (USB_BIT_IS_SET (PortState.PortChangeStatus, USB_PORT_STAT_C_CONNECTION)) {
 909     //
 910     // Case4:
 911     //   Device connected or disconnected normally.
 912     //
 913     DEBUG ((EFI_D_ERROR, "UsbEnumeratePort: Device Connect/Discount Normally\n", Port));
 914   }
 915
 916   //
 917   // Following as the above cases, it's safety to remove and create again.
 918   //
 919   Child = UsbFindChild (HubIf, Port);
 920
 921   if (Child != NULL) {
 922     DEBUG (( EFI_D_INFO, "UsbEnumeratePort: device at port %d removed from root hub %p\n", Port, HubIf));
 923     UsbRemoveDevice (Child);
 924   }
 925
 926   if (USB_BIT_IS_SET (PortState.PortStatus, USB_PORT_STAT_CONNECTION)) {
 927     //
 928     // Now, new device connected, enumerate and configure the device
 929     //
 930     DEBUG (( EFI_D_INFO, "UsbEnumeratePort: new device connected at port %d\n", Port));
 931     Status = UsbEnumerateNewDev (HubIf, Port);
 932
 933   } else {
 934     DEBUG (( EFI_D_INFO, "UsbEnumeratePort: device disconnected event on port %d\n", Port));
 935   }
 936
 937   HubApi->ClearPortChange (HubIf, Port);
 938   return Status;
 939 }
 940
 941
 942 /**
 943   Enumerate all the changed hub ports.
 944
 945   @param  Event                 The event that is triggered.
 946   @param  Context               The context to the event.
 947
 948 **/
 949 VOID
 950 EFIAPI
 951 UsbHubEnumeration (
 952   IN EFI_EVENT            Event,
 953   IN VOID                 *Context
 954   )
 955 {
 956   USB_INTERFACE           *HubIf;
 957   UINT8                   Byte;
 958   UINT8                   Bit;
 959   UINT8                   Index;
 960
 961   ASSERT (Context != NULL);
 962
 963   HubIf = (USB_INTERFACE *) Context;
 964
 965   if (HubIf->ChangeMap == NULL) {
 966     return ;
 967   }
 968
 969   //
 970   // HUB starts its port index with 1.
 971   //
 972   Byte  = 0;
 973   Bit   = 1;
 974
 975   for (Index = 0; Index < HubIf->NumOfPort; Index++) {
 976     if (USB_BIT_IS_SET (HubIf->ChangeMap[Byte], USB_BIT (Bit))) {
 977       UsbEnumeratePort (HubIf, Index);
 978     }
 979
 980     USB_NEXT_BIT (Byte, Bit);
 981   }
 982
 983   UsbHubAckHubStatus (HubIf->Device);
 984
 985   gBS->FreePool (HubIf->ChangeMap);
 986   HubIf->ChangeMap = NULL;
 987   return ;
 988 }
 989
 990
 991 /**
 992   Enumerate all the changed hub ports.
 993
 994   @param  Event                 The event that is triggered.
 995   @param  Context               The context to the event.
 996
 997 **/
 998 VOID
 999 EFIAPI
1000 UsbRootHubEnumeration (
1001   IN EFI_EVENT            Event,
1002   IN VOID                 *Context
1003   )
1004 {
1005   USB_INTERFACE           *RootHub;
1006   UINT8                   Index;
1007
1008   RootHub = (USB_INTERFACE *) Context;
1009
1010   for (Index = 0; Index < RootHub->NumOfPort; Index++) {
1011     UsbEnumeratePort (RootHub, Index);
1012   }
1013 }