/** @file Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.
This program and the accompanying materials are licensed and made available under the terms and conditions of the BSD License which accompanies this distribution. The full text of the license may be found at http://opensource.org/licenses/bsd-license.php THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. **/ #include "PciEmulation.h" EMBEDDED_EXTERNAL_DEVICE *gTPS65950; #define HOST_CONTROLLER_OPERATION_REG_SIZE 0x44 typedef struct { ACPI_HID_DEVICE_PATH AcpiDevicePath; PCI_DEVICE_PATH PciDevicePath; EFI_DEVICE_PATH_PROTOCOL EndDevicePath; } EFI_PCI_IO_DEVICE_PATH; typedef struct { UINT32 Signature; EFI_PCI_IO_DEVICE_PATH DevicePath; EFI_PCI_IO_PROTOCOL PciIoProtocol; PCI_TYPE00 *ConfigSpace; PCI_ROOT_BRIDGE RootBridge; UINTN Segment; } EFI_PCI_IO_PRIVATE_DATA; #define EFI_PCI_IO_PRIVATE_DATA_SIGNATURE SIGNATURE_32('p', 'c', 'i', 'o') #define EFI_PCI_IO_PRIVATE_DATA_FROM_THIS(a) CR(a, EFI_PCI_IO_PRIVATE_DATA, PciIoProtocol, EFI_PCI_IO_PRIVATE_DATA_SIGNATURE) EFI_PCI_IO_DEVICE_PATH PciIoDevicePathTemplate = { { { ACPI_DEVICE_PATH, ACPI_DP, sizeof (ACPI_HID_DEVICE_PATH), 0}, EISA_PNP_ID(0x0A03), // HID 0 // UID }, { { HARDWARE_DEVICE_PATH, HW_PCI_DP, sizeof (PCI_DEVICE_PATH), 0}, 0, 0 }, { END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE, sizeof (EFI_DEVICE_PATH_PROTOCOL), 0} }; STATIC VOID ConfigureUSBHost ( VOID ) { EFI_STATUS Status; UINT8 Data = 0; // Take USB host out of force-standby mode MmioWrite32 (UHH_SYSCONFIG, UHH_SYSCONFIG_MIDLEMODE_NO_STANDBY | UHH_SYSCONFIG_CLOCKACTIVITY_ON | UHH_SYSCONFIG_SIDLEMODE_NO_STANDBY | UHH_SYSCONFIG_ENAWAKEUP_ENABLE | UHH_SYSCONFIG_AUTOIDLE_ALWAYS_RUN); MmioWrite32 (UHH_HOSTCONFIG, UHH_HOSTCONFIG_P3_CONNECT_STATUS_DISCONNECT | UHH_HOSTCONFIG_P2_CONNECT_STATUS_DISCONNECT | UHH_HOSTCONFIG_P1_CONNECT_STATUS_DISCONNECT | UHH_HOSTCONFIG_ENA_INCR_ALIGN_DISABLE | UHH_HOSTCONFIG_ENA_INCR16_ENABLE | UHH_HOSTCONFIG_ENA_INCR8_ENABLE | UHH_HOSTCONFIG_ENA_INCR4_ENABLE | UHH_HOSTCONFIG_AUTOPPD_ON_OVERCUR_EN_ON | UHH_HOSTCONFIG_P1_ULPI_BYPASS_ULPI_MODE); // USB reset (GPIO 147 - Port 5 pin 19) output high MmioAnd32 (GPIO5_BASE + GPIO_OE, ~BIT19); MmioWrite32 (GPIO5_BASE + GPIO_SETDATAOUT, BIT19); // Get the Power IC protocol Status = gBS->LocateProtocol (&gEmbeddedExternalDeviceProtocolGuid, NULL, (VOID **)&gTPS65950); ASSERT_EFI_ERROR (Status); // Power the USB PHY Data = VAUX_DEV_GRP_P1; Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VAUX2_DEV_GRP), 1, &Data); ASSERT_EFI_ERROR(Status); Data = VAUX_DEDICATED_18V; Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VAUX2_DEDICATED), 1, &Data); ASSERT_EFI_ERROR (Status); // Enable power to the USB hub Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID3, LEDEN), 1, &Data); ASSERT_EFI_ERROR (Status); // LEDAON controls the power to the USB host, PWM is disabled Data &= ~LEDAPWM; Data |= LEDAON; Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID3, LEDEN), 1, &Data); ASSERT_EFI_ERROR (Status); } EFI_STATUS PciIoPollMem ( IN EFI_PCI_IO_PROTOCOL *This, IN EFI_PCI_IO_PROTOCOL_WIDTH Width, IN UINT8 BarIndex, IN UINT64 Offset, IN UINT64 Mask, IN UINT64 Value, IN UINT64 Delay, OUT UINT64 *Result ) { ASSERT (FALSE); return EFI_UNSUPPORTED; } EFI_STATUS PciIoPollIo ( IN EFI_PCI_IO_PROTOCOL *This, IN EFI_PCI_IO_PROTOCOL_WIDTH Width, IN UINT8 BarIndex, IN UINT64 Offset, IN UINT64 Mask, IN UINT64 Value, IN UINT64 Delay, OUT UINT64 *Result ) { ASSERT (FALSE); return EFI_UNSUPPORTED; } EFI_STATUS PciIoMemRead ( IN EFI_PCI_IO_PROTOCOL *This, IN EFI_PCI_IO_PROTOCOL_WIDTH Width, IN UINT8 BarIndex, IN UINT64 Offset, IN UINTN Count, IN OUT VOID *Buffer ) { EFI_PCI_IO_PRIVATE_DATA *Private = EFI_PCI_IO_PRIVATE_DATA_FROM_THIS(This); return PciRootBridgeIoMemRead (&Private->RootBridge.Io, (EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH) Width, Private->ConfigSpace->Device.Bar[BarIndex] + Offset, Count, Buffer ); } EFI_STATUS PciIoMemWrite ( IN EFI_PCI_IO_PROTOCOL *This, IN EFI_PCI_IO_PROTOCOL_WIDTH Width, IN UINT8 BarIndex, IN UINT64 Offset, IN UINTN Count, IN OUT VOID *Buffer ) { EFI_PCI_IO_PRIVATE_DATA *Private = EFI_PCI_IO_PRIVATE_DATA_FROM_THIS(This); return PciRootBridgeIoMemWrite (&Private->RootBridge.Io, (EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH) Width, Private->ConfigSpace->Device.Bar[BarIndex] + Offset, Count, Buffer ); } EFI_STATUS PciIoIoRead ( IN EFI_PCI_IO_PROTOCOL *This, IN EFI_PCI_IO_PROTOCOL_WIDTH Width, IN UINT8 BarIndex, IN UINT64 Offset, IN UINTN Count, IN OUT VOID *Buffer ) { ASSERT (FALSE); return EFI_UNSUPPORTED; } EFI_STATUS PciIoIoWrite ( IN EFI_PCI_IO_PROTOCOL *This, IN EFI_PCI_IO_PROTOCOL_WIDTH Width, IN UINT8 BarIndex, IN UINT64 Offset, IN UINTN Count, IN OUT VOID *Buffer ) { ASSERT (FALSE); return EFI_UNSUPPORTED; } EFI_STATUS PciIoPciRead ( IN EFI_PCI_IO_PROTOCOL *This, IN EFI_PCI_IO_PROTOCOL_WIDTH Width, IN UINT32 Offset, IN UINTN Count, IN OUT VOID *Buffer ) { EFI_PCI_IO_PRIVATE_DATA *Private = EFI_PCI_IO_PRIVATE_DATA_FROM_THIS(This); return PciRootBridgeIoMemRW ((EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH)Width, Count, TRUE, (PTR)(UINTN)Buffer, TRUE, (PTR)(UINTN)(((UINT8 *)Private->ConfigSpace) + Offset) ); } EFI_STATUS PciIoPciWrite ( IN EFI_PCI_IO_PROTOCOL *This, IN EFI_PCI_IO_PROTOCOL_WIDTH Width, IN UINT32 Offset, IN UINTN Count, IN OUT VOID *Buffer ) { EFI_PCI_IO_PRIVATE_DATA *Private = EFI_PCI_IO_PRIVATE_DATA_FROM_THIS(This); return PciRootBridgeIoMemRW ((EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH) Width, Count, TRUE, (PTR)(UINTN)(((UINT8 *)Private->ConfigSpace) + Offset), TRUE, (PTR)(UINTN)Buffer ); } EFI_STATUS PciIoCopyMem ( IN EFI_PCI_IO_PROTOCOL *This, IN EFI_PCI_IO_PROTOCOL_WIDTH Width, IN UINT8 DestBarIndex, IN UINT64 DestOffset, IN UINT8 SrcBarIndex, IN UINT64 SrcOffset, IN UINTN Count ) { ASSERT (FALSE); return EFI_UNSUPPORTED; } EFI_STATUS PciIoMap ( IN EFI_PCI_IO_PROTOCOL *This, IN EFI_PCI_IO_PROTOCOL_OPERATION Operation, IN VOID *HostAddress, IN OUT UINTN *NumberOfBytes, OUT EFI_PHYSICAL_ADDRESS *DeviceAddress, OUT VOID **Mapping ) { DMA_MAP_OPERATION DmaOperation; if (Operation == EfiPciIoOperationBusMasterRead) { DmaOperation = MapOperationBusMasterRead; } else if (Operation == EfiPciIoOperationBusMasterWrite) { DmaOperation = MapOperationBusMasterWrite; } else if (Operation == EfiPciIoOperationBusMasterCommonBuffer) { DmaOperation = MapOperationBusMasterCommonBuffer; } else { return EFI_INVALID_PARAMETER; } return DmaMap (DmaOperation, HostAddress, NumberOfBytes, DeviceAddress, Mapping); } EFI_STATUS PciIoUnmap ( IN EFI_PCI_IO_PROTOCOL *This, IN VOID *Mapping ) { return DmaUnmap (Mapping); } EFI_STATUS PciIoAllocateBuffer ( IN EFI_PCI_IO_PROTOCOL *This, IN EFI_ALLOCATE_TYPE Type, IN EFI_MEMORY_TYPE MemoryType, IN UINTN Pages, OUT VOID **HostAddress, IN UINT64 Attributes ) { if (Attributes & EFI_PCI_ATTRIBUTE_INVALID_FOR_ALLOCATE_BUFFER) { // Check this return EFI_UNSUPPORTED; } return DmaAllocateBuffer (MemoryType, Pages, HostAddress); } EFI_STATUS PciIoFreeBuffer ( IN EFI_PCI_IO_PROTOCOL *This, IN UINTN Pages, IN VOID *HostAddress ) { return DmaFreeBuffer (Pages, HostAddress); } EFI_STATUS PciIoFlush ( IN EFI_PCI_IO_PROTOCOL *This ) { return EFI_SUCCESS; } EFI_STATUS PciIoGetLocation ( IN EFI_PCI_IO_PROTOCOL *This, OUT UINTN *SegmentNumber, OUT UINTN *BusNumber, OUT UINTN *DeviceNumber, OUT UINTN *FunctionNumber ) { EFI_PCI_IO_PRIVATE_DATA *Private = EFI_PCI_IO_PRIVATE_DATA_FROM_THIS(This); if (SegmentNumber != NULL) { *SegmentNumber = Private->Segment; } if (BusNumber != NULL) { *BusNumber = 0xff; } if (DeviceNumber != NULL) { *DeviceNumber = 0; } if (FunctionNumber != NULL) { *FunctionNumber = 0; } return EFI_SUCCESS; } EFI_STATUS PciIoAttributes ( IN EFI_PCI_IO_PROTOCOL *This, IN EFI_PCI_IO_PROTOCOL_ATTRIBUTE_OPERATION Operation, IN UINT64 Attributes, OUT UINT64 *Result OPTIONAL ) { switch (Operation) { case EfiPciIoAttributeOperationGet: case EfiPciIoAttributeOperationSupported: if (Result == NULL) { return EFI_INVALID_PARAMETER; } // We are not a real PCI device so just say things we kind of do *Result = EFI_PCI_IO_ATTRIBUTE_MEMORY | EFI_PCI_IO_ATTRIBUTE_BUS_MASTER | EFI_PCI_DEVICE_ENABLE; break; case EfiPciIoAttributeOperationSet: case EfiPciIoAttributeOperationEnable: case EfiPciIoAttributeOperationDisable: // Since we are not a real PCI device no enable/set or disable operations exist. return EFI_SUCCESS; default: ASSERT (FALSE); return EFI_INVALID_PARAMETER; }; return EFI_SUCCESS; } EFI_STATUS PciIoGetBarAttributes ( IN EFI_PCI_IO_PROTOCOL *This, IN UINT8 BarIndex, OUT UINT64 *Supports, OPTIONAL OUT VOID **Resources OPTIONAL ) { ASSERT (FALSE); return EFI_UNSUPPORTED; } EFI_STATUS PciIoSetBarAttributes ( IN EFI_PCI_IO_PROTOCOL *This, IN UINT64 Attributes, IN UINT8 BarIndex, IN OUT UINT64 *Offset, IN OUT UINT64 *Length ) { ASSERT (FALSE); return EFI_UNSUPPORTED; } EFI_PCI_IO_PROTOCOL PciIoTemplate = { PciIoPollMem, PciIoPollIo, PciIoMemRead, PciIoMemWrite, PciIoIoRead, PciIoIoWrite, PciIoPciRead, PciIoPciWrite, PciIoCopyMem, PciIoMap, PciIoUnmap, PciIoAllocateBuffer, PciIoFreeBuffer, PciIoFlush, PciIoGetLocation, PciIoAttributes, PciIoGetBarAttributes, PciIoSetBarAttributes, 0, 0 }; EFI_STATUS EFIAPI PciEmulationEntryPoint ( IN EFI_HANDLE ImageHandle, IN EFI_SYSTEM_TABLE *SystemTable ) { EFI_STATUS Status; EFI_HANDLE Handle; EFI_PCI_IO_PRIVATE_DATA *Private; UINT8 CapabilityLength; UINT8 PhysicalPorts; UINTN Count; //Configure USB host for OMAP3530. ConfigureUSBHost(); // Create a private structure Private = AllocatePool(sizeof(EFI_PCI_IO_PRIVATE_DATA)); if (Private == NULL) { Status = EFI_OUT_OF_RESOURCES; return Status; } Private->Signature = EFI_PCI_IO_PRIVATE_DATA_SIGNATURE; // Fill in signature Private->RootBridge.Signature = PCI_ROOT_BRIDGE_SIGNATURE; // Fake Root Bridge structure needs a signature too Private->RootBridge.MemoryStart = USB_EHCI_HCCAPBASE; // Get the USB capability register base Private->Segment = 0; // Default to segment zero // Find out the capability register length and number of physical ports. CapabilityLength = MmioRead8(Private->RootBridge.MemoryStart); PhysicalPorts = (MmioRead32 (Private->RootBridge.MemoryStart + 0x4)) & 0x0000000F; // Calculate the total size of the USB registers. Private->RootBridge.MemorySize = CapabilityLength + (HOST_CONTROLLER_OPERATION_REG_SIZE + ((4 * PhysicalPorts) - 1)); // Enable Port Power bit in Port status and control registers in EHCI register space. // Port Power Control (PPC) bit in the HCSPARAMS register is already set which indicates // host controller implementation includes port power control. for (Count = 0; Count < PhysicalPorts; Count++) { MmioOr32 ((Private->RootBridge.MemoryStart + CapabilityLength + HOST_CONTROLLER_OPERATION_REG_SIZE + 4*Count), 0x00001000); } // Create fake PCI config space. Private->ConfigSpace = AllocateZeroPool(sizeof(PCI_TYPE00)); if (Private->ConfigSpace == NULL) { Status = EFI_OUT_OF_RESOURCES; FreePool(Private); return Status; } // Configure PCI config space Private->ConfigSpace->Hdr.VendorId = 0x3530; Private->ConfigSpace->Hdr.DeviceId = 0x3530; Private->ConfigSpace->Hdr.ClassCode[0] = 0x20; Private->ConfigSpace->Hdr.ClassCode[1] = 0x03; Private->ConfigSpace->Hdr.ClassCode[2] = 0x0C; Private->ConfigSpace->Device.Bar[0] = Private->RootBridge.MemoryStart; Handle = NULL; // Unique device path. CopyMem(&Private->DevicePath, &PciIoDevicePathTemplate, sizeof(PciIoDevicePathTemplate)); Private->DevicePath.AcpiDevicePath.UID = 0; // Copy protocol structure CopyMem(&Private->PciIoProtocol, &PciIoTemplate, sizeof(PciIoTemplate)); Status = gBS->InstallMultipleProtocolInterfaces(&Handle, &gEfiPciIoProtocolGuid, &Private->PciIoProtocol, &gEfiDevicePathProtocolGuid, &Private->DevicePath, NULL); if (EFI_ERROR(Status)) { DEBUG((EFI_D_ERROR, "PciEmulationEntryPoint InstallMultipleProtocolInterfaces() failed.\n")); } return Status; }