sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Import IsaFloppy Dxe and Pei in IntelFrameworkModulePkg.

Browse Source 
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@3168 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
yshang1
2007-07-10 09:04:15 +00:00
parent cba9012a92
commit 11f43dfd8b
21 changed files with 10257 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

239
IntelFrameworkModulePkg/Bus/Isa/IsaFloppy/Dxe/ComponentName.c Normal file
View File

@@ -0,0 +1,239 @@
/*++
Copyright (c) 2006 - 2007, Intel Corporation. All rights reserved. <BR>
This software and associated documentation (if any) is furnished
under a license and may only be used or copied in accordance
with the terms of the license. Except as permitted by such
license, no part of this software or documentation may be
reproduced, stored in a retrieval system, or transmitted in any
form or by any means without the express written consent of
Intel Corporation.
Module Name:
ComponentName.c
Abstract:
--*/
#include "IsaFloppy.h"
//
// EFI Component Name Protocol
//
EFI_COMPONENT_NAME_PROTOCOL gIsaFloppyComponentName = {
IsaFloppyComponentNameGetDriverName,
IsaFloppyComponentNameGetControllerName,
"eng"
};
STATIC EFI_UNICODE_STRING_TABLE mIsaFloppyDriverNameTable[] = {
{
"eng",
L"ISA Floppy Driver"
},
{
NULL,
NULL
}
};
EFI_STATUS
EFIAPI
IsaFloppyComponentNameGetDriverName (
IN EFI_COMPONENT_NAME_PROTOCOL *This,
IN CHAR8 *Language,
OUT CHAR16 **DriverName
)
/*++
Routine Description:
Retrieves a Unicode string that is the user readable name of the EFI Driver.
Arguments:
This - A pointer to the EFI_COMPONENT_NAME_PROTOCOL instance.
Language - A pointer to a three character ISO 639-2 language identifier.
This is the language of the driver name that that the caller
is requesting, and it must match one of the languages specified
in SupportedLanguages. The number of languages supported by a
driver is up to the driver writer.
DriverName - A pointer to the Unicode string to return. This Unicode string
is the name of the driver specified by This in the language
specified by Language.
Returns:
EFI_SUCCESS - The Unicode string for the Driver specified by This
and the language specified by Language was returned
in DriverName.
EFI_INVALID_PARAMETER - Language is NULL.
EFI_INVALID_PARAMETER - DriverName is NULL.
EFI_UNSUPPORTED - The driver specified by This does not support the
language specified by Language.
--*/
{
return LookupUnicodeString (
Language,
gIsaFloppyComponentName.SupportedLanguages,
mIsaFloppyDriverNameTable,
DriverName
);
}
EFI_STATUS
EFIAPI
IsaFloppyComponentNameGetControllerName (
IN EFI_COMPONENT_NAME_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN EFI_HANDLE ChildHandle OPTIONAL,
IN CHAR8 *Language,
OUT CHAR16 **ControllerName
)
/*++
Routine Description:
Retrieves a Unicode string that is the user readable name of the controller
that is being managed by an EFI Driver.
Arguments:
This - A pointer to the EFI_COMPONENT_NAME_PROTOCOL instance.
ControllerHandle - The handle of a controller that the driver specified by
This is managing. This handle specifies the controller
whose name is to be returned.
ChildHandle - The handle of the child controller to retrieve the name
of. This is an optional parameter that may be NULL. It
will be NULL for device drivers. It will also be NULL
for a bus drivers that wish to retrieve the name of the
bus controller. It will not be NULL for a bus driver
that wishes to retrieve the name of a child controller.
Language - A pointer to a three character ISO 639-2 language
identifier. This is the language of the controller name
that that the caller is requesting, and it must match one
of the languages specified in SupportedLanguages. The
number of languages supported by a driver is up to the
driver writer.
ControllerName - A pointer to the Unicode string to return. This Unicode
string is the name of the controller specified by
ControllerHandle and ChildHandle in the language
specified by Language from the point of view of the
driver specified by This.
Returns:
EFI_SUCCESS - The Unicode string for the user readable name in the
language specified by Language for the driver
specified by This was returned in DriverName.
EFI_INVALID_PARAMETER - ControllerHandle is not a valid EFI_HANDLE.
EFI_INVALID_PARAMETER - ChildHandle is not NULL and it is not a valid
EFI_HANDLE.
EFI_INVALID_PARAMETER - Language is NULL.
EFI_INVALID_PARAMETER - ControllerName is NULL.
EFI_UNSUPPORTED - The driver specified by This is not currently
managing the controller specified by
ControllerHandle and ChildHandle.
EFI_UNSUPPORTED - The driver specified by This does not support the
language specified by Language.
--*/
{
EFI_STATUS Status;
EFI_BLOCK_IO_PROTOCOL *BlkIo;
FDC_BLK_IO_DEV *FdcDev;
EFI_ISA_IO_PROTOCOL *IsaIoProtocol;
//
// This is a device driver, so ChildHandle must be NULL.
//
if (ChildHandle != NULL) {
return EFI_UNSUPPORTED;
}
//
// Check Controller's handle
//
Status = gBS->OpenProtocol (
ControllerHandle,
&gEfiIsaIoProtocolGuid,
(VOID **) &IsaIoProtocol,
gFdcControllerDriver.DriverBindingHandle,
ControllerHandle,
EFI_OPEN_PROTOCOL_BY_DRIVER
);
if (!EFI_ERROR (Status)) {
gBS->CloseProtocol (
ControllerHandle,
&gEfiIsaIoProtocolGuid,
gFdcControllerDriver.DriverBindingHandle,
ControllerHandle
);
return EFI_UNSUPPORTED;
}
if (Status != EFI_ALREADY_STARTED) {
return EFI_UNSUPPORTED;
}
//
// Get the Block I/O Protocol on Controller
//
Status = gBS->OpenProtocol (
ControllerHandle,
&gEfiBlockIoProtocolGuid,
(VOID **) &BlkIo,
gFdcControllerDriver.DriverBindingHandle,
ControllerHandle,
EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Get the Floppy Disk Controller's Device structure
//
FdcDev = FDD_BLK_IO_FROM_THIS (BlkIo);
return LookupUnicodeString (
Language,
gIsaFloppyComponentName.SupportedLanguages,
FdcDev->ControllerNameTable,
ControllerName
);
}
VOID
AddName (
IN FDC_BLK_IO_DEV *FdcDev
)
/*++
Routine Description:
Add the component name for the floppy device
Arguments:
FdcDev - A pointer to the FDC_BLK_IO_DEV instance.
Returns:
None
--*/
{
CHAR16 FloppyDriveName[FLOPPY_DRIVE_NAME_ASCII_LEN + 1];
StrCpy (FloppyDriveName, FLOPPY_DRIVE_NAME);
FloppyDriveName[FLOPPY_DRIVE_NAME_ASCII_LEN - 1] = (CHAR16) (L'0' + FdcDev->Disk);
AddUnicodeString (
"eng",
gIsaFloppyComponentName.SupportedLanguages,
&FdcDev->ControllerNameTable,
FloppyDriveName
);
}

111
IntelFrameworkModulePkg/Bus/Isa/IsaFloppy/Dxe/ComponentName.h Normal file
View File

@@ -0,0 +1,111 @@
/*++
Copyright (c) 2006, Intel Corporation. All rights reserved.
This software and associated documentation (if any) is furnished
under a license and may only be used or copied in accordance
with the terms of the license. Except as permitted by such
license, no part of this software or documentation may be
reproduced, stored in a retrieval system, or transmitted in any
form or by any means without the express written consent of
Intel Corporation.
Module Name:
ComponentName.h
Abstract:
Revision History:
--*/
#ifndef _ISA_FLOPPY_COMPONENT_NAME_H
#define _ISA_FLOPPY_COMPONENT_NAME_H
#define FLOPPY_DRIVE_NAME L"ISA Floppy Drive # "
#define FLOPPY_DRIVE_NAME_ASCII_LEN (sizeof ("ISA Floppy Drive # ") - 1)
#define ADD_FLOPPY_NAME(x) AddName ((x))
extern EFI_COMPONENT_NAME_PROTOCOL gIsaFloppyComponentName;
//
// EFI Component Name Functions
//
EFI_STATUS
EFIAPI
IsaFloppyComponentNameGetDriverName (
IN EFI_COMPONENT_NAME_PROTOCOL *This,
IN CHAR8 *Language,
OUT CHAR16 **DriverName
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
This - GC_TODO: add argument description
Language - GC_TODO: add argument description
DriverName - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
;
EFI_STATUS
EFIAPI
IsaFloppyComponentNameGetControllerName (
IN EFI_COMPONENT_NAME_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN EFI_HANDLE ChildHandle OPTIONAL,
IN CHAR8 *Language,
OUT CHAR16 **ControllerName
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
This - GC_TODO: add argument description
ControllerHandle - GC_TODO: add argument description
ChildHandle - GC_TODO: add argument description
Language - GC_TODO: add argument description
ControllerName - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
;
VOID
AddName (
IN FDC_BLK_IO_DEV *FdcDev
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
FdcDev - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
;
#endif

55
IntelFrameworkModulePkg/Bus/Isa/IsaFloppy/Dxe/EntryPoint.c Normal file
View File

@@ -0,0 +1,55 @@
/**@file
Entry Point Source file.
This file contains the user entry point
Copyright (c) 2006 - 2007, Intel Corporation.
All rights reserved.
This software and associated documentation (if any) is furnished
under a license and may only be used or copied in accordance
with the terms of the license. Except as permitted by such
license, no part of this software or documentation may be
reproduced, stored in a retrieval system, or transmitted in any
form or by any means without the express written consent of
Intel Corporation.
**/
#include "IsaFloppy.h"
/**
The user Entry Point for module IsaFloppy. The user code starts with this function.
@param[in] ImageHandle The firmware allocated handle for the EFI image.
@param[in] SystemTable A pointer to the EFI System Table.
@retval EFI_SUCCESS The entry point is executed successfully.
@retval other Some error occurs when executing this entry point.
**/
EFI_STATUS
EFIAPI
InitializeIsaFloppy(
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
//
// Install driver model protocol(s).
//
Status = EfiLibInstallAllDriverProtocols (
ImageHandle,
SystemTable,
&gFdcControllerDriver,
ImageHandle,
&gIsaFloppyComponentName,
NULL,
NULL
);
ASSERT_EFI_ERROR (Status);
return Status;
}

451
IntelFrameworkModulePkg/Bus/Isa/IsaFloppy/Dxe/IsaFloppy.c Normal file
View File

@@ -0,0 +1,451 @@
/*++
Copyright (c) 2006 - 2007, Intel Corporation. All rights reserved. <BR>
This software and associated documentation (if any) is furnished
under a license and may only be used or copied in accordance
with the terms of the license. Except as permitted by such
license, no part of this software or documentation may be
reproduced, stored in a retrieval system, or transmitted in any
form or by any means without the express written consent of
Intel Corporation.
Module Name:
IsaFloppy.c
Abstract:
ISA Floppy Driver
1. Support two types diskette drive
1.44M drive and 2.88M drive (and now only support 1.44M)
2. Support two diskette drives
3. Use DMA channel 2 to transfer data
4. Do not use interrupt
5. Support diskette change line signal and write protect
conforming to EFI driver model
Revision History:
--*/
#include "IsaFloppy.h"
LIST_ENTRY gControllerHead = INITIALIZE_LIST_HEAD_VARIABLE(gControllerHead);
//
// ISA Floppy Driver Binding Protocol
//
EFI_DRIVER_BINDING_PROTOCOL gFdcControllerDriver = {
FdcControllerDriverSupported,
FdcControllerDriverStart,
FdcControllerDriverStop,
0xa,
NULL,
NULL
};
EFI_STATUS
EFIAPI
FdcControllerDriverSupported (
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE Controller,
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
)
/*++
Routine Description:
ControllerDriver Protocol Method
Arguments:
Returns:
--*/
// GC_TODO: This - add argument and description to function comment
// GC_TODO: Controller - add argument and description to function comment
// GC_TODO: RemainingDevicePath - add argument and description to function comment
{
EFI_STATUS Status;
EFI_ISA_IO_PROTOCOL *IsaIo;
//
// Open the ISA I/O Protocol
//
Status = gBS->OpenProtocol (
Controller,
&gEfiIsaIoProtocolGuid,
(VOID **) &IsaIo,
This->DriverBindingHandle,
Controller,
EFI_OPEN_PROTOCOL_BY_DRIVER
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Use the ISA I/O Protocol to see if Controller is a Floppy Disk Controller
//
Status = EFI_SUCCESS;
if (IsaIo->ResourceList->Device.HID != EISA_PNP_ID (0x604)) {
Status = EFI_UNSUPPORTED;
}
//
// Close the ISA I/O Protocol
//
gBS->CloseProtocol (
Controller,
&gEfiIsaIoProtocolGuid,
This->DriverBindingHandle,
Controller
);
return Status;
}
EFI_STATUS
EFIAPI
FdcControllerDriverStart (
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE Controller,
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
)
/*++
Routine Description:
Arguments:
Returns:
--*/
// GC_TODO: This - add argument and description to function comment
// GC_TODO: Controller - add argument and description to function comment
// GC_TODO: RemainingDevicePath - add argument and description to function comment
{
EFI_STATUS Status;
FDC_BLK_IO_DEV *FdcDev;
EFI_ISA_IO_PROTOCOL *IsaIo;
UINTN Index;
LIST_ENTRY *List;
BOOLEAN Found;
EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath;
FdcDev = NULL;
IsaIo = NULL;
//
// Open the device path protocol
//
Status = gBS->OpenProtocol (
Controller,
&gEfiDevicePathProtocolGuid,
(VOID **) &ParentDevicePath,
This->DriverBindingHandle,
Controller,
EFI_OPEN_PROTOCOL_BY_DRIVER
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Report enable progress code
//
REPORT_STATUS_CODE_WITH_DEVICE_PATH (
EFI_PROGRESS_CODE,
EFI_PERIPHERAL_REMOVABLE_MEDIA | EFI_P_PC_ENABLE,
ParentDevicePath
);
//
// Open the ISA I/O Protocol
//
Status = gBS->OpenProtocol (
Controller,
&gEfiIsaIoProtocolGuid,
(VOID **) &IsaIo,
This->DriverBindingHandle,
Controller,
EFI_OPEN_PROTOCOL_BY_DRIVER
);
if (EFI_ERROR (Status)) {
goto Done;
}
//
// Allocate the Floppy Disk Controller's Device structure
//
FdcDev = AllocateZeroPool (sizeof (FDC_BLK_IO_DEV));
if (FdcDev == NULL) {
goto Done;
}
//
// Initialize the Floppy Disk Controller's Device structure
//
FdcDev->Signature = FDC_BLK_IO_DEV_SIGNATURE;
FdcDev->Handle = Controller;
FdcDev->IsaIo = IsaIo;
FdcDev->Disk = (EFI_FDC_DISK) IsaIo->ResourceList->Device.UID;
FdcDev->Cache = NULL;
FdcDev->Event = NULL;
FdcDev->ControllerState = NULL;
FdcDev->DevicePath = ParentDevicePath;
ADD_FLOPPY_NAME (FdcDev);
//
// Look up the base address of the Floppy Disk Controller
//
for (Index = 0; FdcDev->IsaIo->ResourceList->ResourceItem[Index].Type != EfiIsaAcpiResourceEndOfList; Index++) {
if (FdcDev->IsaIo->ResourceList->ResourceItem[Index].Type == EfiIsaAcpiResourceIo) {
FdcDev->BaseAddress = (UINT16) FdcDev->IsaIo->ResourceList->ResourceItem[Index].StartRange;
}
}
//
// Maintain the list of controller list
//
Found = FALSE;
List = gControllerHead.ForwardLink;
while (List != &gControllerHead) {
FdcDev->ControllerState = FLOPPY_CONTROLLER_FROM_LIST_ENTRY (List);
if (FdcDev->BaseAddress == FdcDev->ControllerState->BaseAddress) {
Found = TRUE;
break;
}
List = List->ForwardLink;
}
if (!Found) {
//
// The Controller is new
//
FdcDev->ControllerState = AllocatePool (sizeof (FLOPPY_CONTROLLER_CONTEXT));
if (FdcDev->ControllerState == NULL) {
goto Done;
}
FdcDev->ControllerState->Signature = FLOPPY_CONTROLLER_CONTEXT_SIGNATURE;
FdcDev->ControllerState->FddResetPerformed = FALSE;
FdcDev->ControllerState->NeedRecalibrate = FALSE;
FdcDev->ControllerState->BaseAddress = FdcDev->BaseAddress;
FdcDev->ControllerState->NumberOfDrive = 0;
InsertTailList (&gControllerHead, &FdcDev->ControllerState->Link);
}
//
// Create a timer event for each Floppd Disk Controller.
// This timer event is used to control the motor on and off
//
Status = gBS->CreateEvent (
EVT_TIMER | EVT_NOTIFY_SIGNAL,
TPL_NOTIFY,
FddTimerProc,
FdcDev,
&FdcDev->Event
);
if (EFI_ERROR (Status)) {
goto Done;
}
//
// Reset the Floppy Disk Controller
//
if (!FdcDev->ControllerState->FddResetPerformed) {
FdcDev->ControllerState->FddResetPerformed = TRUE;
FdcDev->ControllerState->FddResetStatus = FddReset (FdcDev);
}
if (EFI_ERROR (FdcDev->ControllerState->FddResetStatus)) {
Status = EFI_DEVICE_ERROR;
goto Done;
}
REPORT_STATUS_CODE_WITH_DEVICE_PATH (
EFI_PROGRESS_CODE,
EFI_PERIPHERAL_REMOVABLE_MEDIA | EFI_P_PC_PRESENCE_DETECT,
ParentDevicePath
);
//
// Discover the Floppy Drive
//
Status = DiscoverFddDevice (FdcDev);
if (EFI_ERROR (Status)) {
Status = EFI_DEVICE_ERROR;
goto Done;
}
//
// Install protocol interfaces for the serial device.
//
Status = gBS->InstallMultipleProtocolInterfaces (
&Controller,
&gEfiBlockIoProtocolGuid,
&FdcDev->BlkIo,
NULL
);
FdcDev->ControllerState->NumberOfDrive++;
Done:
if (EFI_ERROR (Status)) {
REPORT_STATUS_CODE_WITH_DEVICE_PATH (
EFI_ERROR_CODE | EFI_ERROR_MINOR,
EFI_PERIPHERAL_REMOVABLE_MEDIA | EFI_P_EC_CONTROLLER_ERROR,
ParentDevicePath
);
//
// Close the device path protocol
//
gBS->CloseProtocol (
Controller,
&gEfiDevicePathProtocolGuid,
This->DriverBindingHandle,
Controller
);
//
// Close the ISA I/O Protocol
//
if (IsaIo != NULL) {
gBS->CloseProtocol (
Controller,
&gEfiIsaIoProtocolGuid,
This->DriverBindingHandle,
Controller
);
}
//
// If a Floppy Disk Controller Device structure was allocated, then free it
//
if (FdcDev != NULL) {
if (FdcDev->Event != NULL) {
//
// Close the event for turning the motor off
//
gBS->CloseEvent (FdcDev->Event);
}
FreeUnicodeStringTable (FdcDev->ControllerNameTable);
gBS->FreePool (FdcDev);
}
}
return Status;
}
EFI_STATUS
EFIAPI
FdcControllerDriverStop (
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE Controller,
IN UINTN NumberOfChildren,
IN EFI_HANDLE *ChildHandleBuffer
)
/*++
Routine Description:
Arguments:
Returns:
--*/
// GC_TODO: This - add argument and description to function comment
// GC_TODO: Controller - add argument and description to function comment
// GC_TODO: NumberOfChildren - add argument and description to function comment
// GC_TODO: ChildHandleBuffer - add argument and description to function comment
// GC_TODO: EFI_SUCCESS - add return value to function comment
{
EFI_STATUS Status;
EFI_BLOCK_IO_PROTOCOL *BlkIo;
FDC_BLK_IO_DEV *FdcDev;
//
// Get the Block I/O Protocol on Controller
//
Status = gBS->OpenProtocol (
Controller,
&gEfiBlockIoProtocolGuid,
(VOID **) &BlkIo,
This->DriverBindingHandle,
Controller,
EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Get the Floppy Disk Controller's Device structure
//
FdcDev = FDD_BLK_IO_FROM_THIS (BlkIo);
//
// Report disable progress code
//
REPORT_STATUS_CODE_WITH_DEVICE_PATH (
EFI_PROGRESS_CODE,
EFI_PERIPHERAL_REMOVABLE_MEDIA | EFI_P_PC_DISABLE,
FdcDev->DevicePath
);
//
// Turn the motor off on the Floppy Disk Controller
//
FddTimerProc (FdcDev->Event, FdcDev);
//
// Uninstall the Block I/O Protocol
//
Status = gBS->UninstallProtocolInterface (
Controller,
&gEfiBlockIoProtocolGuid,
&FdcDev->BlkIo
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Close the device path protocol
//
gBS->CloseProtocol (
Controller,
&gEfiDevicePathProtocolGuid,
This->DriverBindingHandle,
Controller
);
//
// Close the ISA I/O Protocol
//
gBS->CloseProtocol (
Controller,
&gEfiIsaIoProtocolGuid,
This->DriverBindingHandle,
Controller
);
//
// Free the controller list if needed
//
FdcDev->ControllerState->NumberOfDrive--;
//
// Close the event for turning the motor off
//
gBS->CloseEvent (FdcDev->Event);
//
// Free the cache if one was allocated
//
FdcFreeCache (FdcDev);
//
// Free the Floppy Disk Controller's Device structure
//
FreeUnicodeStringTable (FdcDev->ControllerNameTable);
gBS->FreePool (FdcDev);
return EFI_SUCCESS;
}

1321
IntelFrameworkModulePkg/Bus/Isa/IsaFloppy/Dxe/IsaFloppy.h Normal file
View File

File diff suppressed because it is too large Load Diff

109
IntelFrameworkModulePkg/Bus/Isa/IsaFloppy/Dxe/IsaFloppy.inf Normal file
View File

@@ -0,0 +1,109 @@
#/** @file
# Component description file for IsaFloppy module.
#
# ISA Floppy Driver
# 1. Support two types diskette drive
# 1.44M drive and 2.88M drive (and now only support 1.44M)
# 2. Support two diskette drives
# 3. Use DMA channel 2 to transfer data
# 4. Do not use interrupt
# 5. Support diskette change line signal and write protect
#
# Conforming to EFI driver model
# Copyright (c) 2006 - 2007, Intel Corporation.
#
# All rights reserved.
# This software and associated documentation (if any) is furnished
# under a license and may only be used or copied in accordance
# with the terms of the license. Except as permitted by such
# license, no part of this software or documentation may be
# reproduced, stored in a retrieval system, or transmitted in any
# form or by any means without the express written consent of
# Intel Corporation.
#
#
#**/
################################################################################
#
# Defines Section - statements that will be processed to create a Makefile.
#
################################################################################
[Defines]
INF_VERSION = 0x00010005
BASE_NAME = IsaFloppy
FILE_GUID = 0abd8284-6da3-4616-971a-83a5148067ba
MODULE_TYPE = DXE_DRIVER
VERSION_STRING = 1.0
EDK_RELEASE_VERSION = 0x00020000
EFI_SPECIFICATION_VERSION = 0x00020000
ENTRY_POINT = InitializeIsaFloppy
#
# The following information is for reference only and not required by the build tools.
#
# VALID_ARCHITECTURES = IA32 X64 IPF EBC
#
# DRIVER_BINDING = gFdcControllerDriver
# COMPONENT_NAME = gIsaFloppyComponentName
# Create Event Guid C Name: Event Type: EVENT_TYPE_PERIODIC_TIMER
#
#
################################################################################
#
# Sources Section - list of files that are required for the build to succeed.
#
################################################################################
[Sources.common]
ComponentName.c
ComponentName.h
IsaFloppyCtrl.c
IsaFloppyBlock.c
IsaFloppy.c
IsaFloppy.h
EntryPoint.c
################################################################################
#
# Package Dependency Section - list of Package files that are required for
# this module.
#
################################################################################
[Packages]
MdePkg/MdePkg.dec
IntelFrameworkPkg/IntelFrameworkPkg.dec
################################################################################
#
# Library Class Section - list of Library Classes that are required for
# this module.
#
################################################################################
[LibraryClasses]
ReportStatusCodeLib
UefiBootServicesTableLib
MemoryAllocationLib
BaseMemoryLib
UefiLib
BaseLib
UefiDriverEntryPoint
DebugLib
TimerLib
################################################################################
#
# Protocol C Name Section - list of Protocol and Protocol Notify C Names
# that this module uses or produces.
#
################################################################################
[Protocols]
gEfiIsaIoProtocolGuid # PROTOCOL TO_START
gEfiBlockIoProtocolGuid # PROTOCOL BY_START
gEfiDevicePathProtocolGuid # PROTOCOL TO_START

105
IntelFrameworkModulePkg/Bus/Isa/IsaFloppy/Dxe/IsaFloppy.msa Normal file
View File

@@ -0,0 +1,105 @@
<?xml version="1.0" encoding="UTF-8"?>
<ModuleSurfaceArea xsi:schemaLocation="http://www.TianoCore.org/2006/Edk2.0 http://www.TianoCore.org/2006/Edk2.0/SurfaceArea.xsd" xmlns="http://www.TianoCore.org/2006/Edk2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<MsaHeader>
<ModuleName>IsaFloppy</ModuleName>
<ModuleType>DXE_DRIVER</ModuleType>
<GuidValue>0abd8284-6da3-4616-971a-83a5148067ba</GuidValue>
<Version>1.0</Version>
<Abstract>Component description file for IsaFloppy module.</Abstract>
<Description>ISA Floppy Driver
1. Support two types diskette drive
1.44M drive and 2.88M drive (and now only support 1.44M)
2. Support two diskette drives
3. Use DMA channel 2 to transfer data
4. Do not use interrupt
5. Support diskette change line signal and write protect
Conforming to EFI driver model</Description>
<Copyright>Copyright (c) 2006 - 2007, Intel Corporation.</Copyright>
<License>All rights reserved.
This software and associated documentation (if any) is furnished
under a license and may only be used or copied in accordance
with the terms of the license. Except as permitted by such
license, no part of this software or documentation may be
reproduced, stored in a retrieval system, or transmitted in any
form or by any means without the express written consent of
Intel Corporation.</License>
<Specification>FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052</Specification>
</MsaHeader>
<ModuleDefinitions>
<SupportedArchitectures>IA32 X64 IPF EBC</SupportedArchitectures>
<BinaryModule>false</BinaryModule>
<OutputFileBasename>IsaFloppy</OutputFileBasename>
</ModuleDefinitions>
<LibraryClassDefinitions>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>TimerLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>DebugLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>UefiDriverModelLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>UefiDriverEntryPoint</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>BaseLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>UefiLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>BaseMemoryLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>MemoryAllocationLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>UefiBootServicesTableLib</Keyword>
</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">
<Keyword>ReportStatusCodeLib</Keyword>
</LibraryClass>
</LibraryClassDefinitions>
<SourceFiles>
<Filename>IsaFloppy.h</Filename>
<Filename>IsaFloppy.c</Filename>
<Filename>IsaFloppyBlock.c</Filename>
<Filename>IsaFloppyCtrl.c</Filename>
<Filename>ComponentName.h</Filename>
<Filename>ComponentName.c</Filename>
</SourceFiles>
<PackageDependencies>
<Package PackageGuid="5e0e9358-46b6-4ae2-8218-4ab8b9bbdcec"/>
<Package PackageGuid="68169ab0-d41b-4009-9060-292c253ac43d"/>
</PackageDependencies>
<Protocols>
<Protocol Usage="TO_START">
<ProtocolCName>gEfiDevicePathProtocolGuid</ProtocolCName>
</Protocol>
<Protocol Usage="BY_START">
<ProtocolCName>gEfiBlockIoProtocolGuid</ProtocolCName>
</Protocol>
<Protocol Usage="TO_START">
<ProtocolCName>gEfiIsaIoProtocolGuid</ProtocolCName>
</Protocol>
</Protocols>
<Events>
<CreateEvents>
<EventTypes Usage="ALWAYS_CONSUMED">
<EventType>EVENT_TYPE_PERIODIC_TIMER</EventType>
<HelpText>Timer event for each Floppd Disk Controller to control the motor on and off.</HelpText>
</EventTypes>
</CreateEvents>
</Events>
<Externs>
<Specification>EFI_SPECIFICATION_VERSION 0x00020000</Specification>
<Specification>EDK_RELEASE_VERSION 0x00020000</Specification>
<Extern>
<DriverBinding>gFdcControllerDriver</DriverBinding>
<ComponentName>gIsaFloppyComponentName</ComponentName>
</Extern>
</Externs>
</ModuleSurfaceArea>

458
IntelFrameworkModulePkg/Bus/Isa/IsaFloppy/Dxe/IsaFloppyBlock.c Normal file
View File

@@ -0,0 +1,458 @@
/*++
Copyright (c) 2006, Intel Corporation. All rights reserved. <BR>
This software and associated documentation (if any) is furnished
under a license and may only be used or copied in accordance
with the terms of the license. Except as permitted by such
license, no part of this software or documentation may be
reproduced, stored in a retrieval system, or transmitted in any
form or by any means without the express written consent of
Intel Corporation.
Module Name:
IsaFloppyBlock.c
Abstract:
ISA Floppy Driver
1. Support two types diskette drive
1.44M drive and 2.88M drive (and now only support 1.44M)
2. Support two diskette drives
3. Use DMA channel 2 to transfer data
4. Do not use interrupt
5. Support diskette change line signal and write protect
Implement the Block IO interface
Revision History:
--*/
#include "IsaFloppy.h"
EFI_STATUS
EFIAPI
FdcReset (
IN EFI_BLOCK_IO_PROTOCOL *This,
IN BOOLEAN ExtendedVerification
)
/*++
Routine Description: Reset the Floppy Logic Drive, call the FddReset function
Parameters:
This EFI_BLOCK_IO *: A pointer to the Block I/O protocol interface
ExtendedVerification BOOLEAN: Indicate that the driver may perform a more
exhaustive verification operation of the device during
reset, now this par is ignored in this driver
Returns:
EFI_SUCCESS: The Floppy Logic Drive is reset
EFI_DEVICE_ERROR: The Floppy Logic Drive is not functioning correctly
and can not be reset
--*/
// GC_TODO: function comment is missing 'Arguments:'
// GC_TODO: This - add argument and description to function comment
// GC_TODO: ExtendedVerification - add argument and description to function comment
{
FDC_BLK_IO_DEV *FdcDev;
//
// Reset the Floppy Disk Controller
//
FdcDev = FDD_BLK_IO_FROM_THIS (This);
REPORT_STATUS_CODE_WITH_DEVICE_PATH (
EFI_PROGRESS_CODE,
EFI_P_PC_RESET | EFI_PERIPHERAL_REMOVABLE_MEDIA,
FdcDev->DevicePath
);
return FddReset (FdcDev);
}
EFI_STATUS
EFIAPI
FddFlushBlocks (
IN EFI_BLOCK_IO_PROTOCOL *This
)
/*++
Routine Description:
Parameters:
This EFI_BLOCK_IO *: A pointer to the Block I/O protocol interface
Returns:
EFI_SUCCESS:
--*/
// GC_TODO: function comment is missing 'Arguments:'
// GC_TODO: This - add argument and description to function comment
{
//
// Not supported yet
//
return EFI_SUCCESS;
}
STATIC
VOID
FddReportStatus (
IN EFI_BLOCK_IO_PROTOCOL *This,
IN BOOLEAN Read
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
This - GC_TODO: add argument description
Read - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
FDC_BLK_IO_DEV *FdcDev;
FdcDev = FDD_BLK_IO_FROM_THIS (This);
REPORT_STATUS_CODE_WITH_DEVICE_PATH (
EFI_ERROR_CODE,
((Read) ? EFI_P_EC_INPUT_ERROR : EFI_P_EC_OUTPUT_ERROR) | EFI_PERIPHERAL_REMOVABLE_MEDIA,
FdcDev->DevicePath
);
}
EFI_STATUS
EFIAPI
FddReadBlocks (
IN EFI_BLOCK_IO_PROTOCOL *This,
IN UINT32 MediaId,
IN EFI_LBA LBA,
IN UINTN BufferSize,
OUT VOID *Buffer
)
/*++
Routine Description: Read the requested number of blocks from the device
Parameters:
This EFI_BLOCK_IO *: A pointer to the Block I/O protocol interface
MediaId UINT32: The media id that the read request is for
LBA EFI_LBA: The starting logic block address to read from on the device
BufferSize UINTN: The size of the Buffer in bytes
Buffer VOID *: A pointer to the destination buffer for the data
Returns:
EFI_SUCCESS: The data was read correctly from the device
EFI_DEVICE_ERROR:The device reported an error while attempting to perform
the read operation
EFI_NO_MEDIA: There is no media in the device
EFI_MEDIA_CHANGED: The MediaId is not for the current media
EFI_BAD_BUFFER_SIZE: The BufferSize parameter is not a multiple of the
intrinsic block size of the device
EFI_INVALID_PARAMETER:The read request contains LBAs that are not valid,
or the buffer is not on proper alignment
--*/
// GC_TODO: function comment is missing 'Arguments:'
// GC_TODO: This - add argument and description to function comment
// GC_TODO: MediaId - add argument and description to function comment
// GC_TODO: LBA - add argument and description to function comment
// GC_TODO: BufferSize - add argument and description to function comment
// GC_TODO: Buffer - add argument and description to function comment
{
EFI_STATUS Status;
Status = FddReadWriteBlocks (This, MediaId, LBA, BufferSize, READ, Buffer);
if (EFI_ERROR (Status)) {
FddReportStatus (This, TRUE);
}
return Status;
}
EFI_STATUS
EFIAPI
FddWriteBlocks (
IN EFI_BLOCK_IO_PROTOCOL *This,
IN UINT32 MediaId,
IN EFI_LBA LBA,
IN UINTN BufferSize,
IN VOID *Buffer
)
/*++
Routine Description: Write a specified number of blocks to the device
Parameters:
This EFI_BLOCK_IO *: A pointer to the Block I/O protocol interface
MediaId UINT32: The media id that the write request is for
LBA EFI_LBA: The starting logic block address to be written
BufferSize UINTN: The size in bytes in Buffer
Buffer VOID *: A pointer to the source buffer for the data
Returns :
EFI_SUCCESS: The data were written correctly to the device
EFI_WRITE_PROTECTED: The device can not be written to
EFI_NO_MEDIA: There is no media in the device
EFI_MEDIA_CHANGED: The MediaId is not for the current media
EFI_DEVICE_ERROR: The device reported an error while attempting to perform
the write operation
EFI_BAD_BUFFER_SIZE: The BufferSize parameter is not a multiple of the
intrinsic block size of the device
EFI_INVALID_PARAMETER:The write request contains LBAs that are not valid,
or the buffer is not on proper alignment
--*/
// GC_TODO: function comment is missing 'Arguments:'
// GC_TODO: function comment is missing 'Returns:'
// GC_TODO: This - add argument and description to function comment
// GC_TODO: MediaId - add argument and description to function comment
// GC_TODO: LBA - add argument and description to function comment
// GC_TODO: BufferSize - add argument and description to function comment
// GC_TODO: Buffer - add argument and description to function comment
{
EFI_STATUS Status;
Status = FddReadWriteBlocks (This, MediaId, LBA, BufferSize, WRITE, Buffer);
if (EFI_ERROR (Status)) {
FddReportStatus (This, FALSE);
}
return Status;
}
EFI_STATUS
FddReadWriteBlocks (
IN EFI_BLOCK_IO_PROTOCOL *This,
IN UINT32 MediaId,
IN EFI_LBA LBA,
IN UINTN BufferSize,
IN BOOLEAN Operation,
OUT VOID *Buffer
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
This - GC_TODO: add argument description
MediaId - GC_TODO: add argument description
LBA - GC_TODO: add argument description
BufferSize - GC_TODO: add argument description
Operation - GC_TODO: add argument description
Buffer - GC_TODO: add argument description
Returns:
EFI_INVALID_PARAMETER - GC_TODO: Add description for return value
EFI_SUCCESS - GC_TODO: Add description for return value
EFI_DEVICE_ERROR - GC_TODO: Add description for return value
EFI_DEVICE_ERROR - GC_TODO: Add description for return value
EFI_NO_MEDIA - GC_TODO: Add description for return value
EFI_MEDIA_CHANGED - GC_TODO: Add description for return value
EFI_WRITE_PROTECTED - GC_TODO: Add description for return value
EFI_BAD_BUFFER_SIZE - GC_TODO: Add description for return value
EFI_INVALID_PARAMETER - GC_TODO: Add description for return value
EFI_INVALID_PARAMETER - GC_TODO: Add description for return value
EFI_SUCCESS - GC_TODO: Add description for return value
EFI_DEVICE_ERROR - GC_TODO: Add description for return value
EFI_DEVICE_ERROR - GC_TODO: Add description for return value
EFI_SUCCESS - GC_TODO: Add description for return value
--*/
{
EFI_BLOCK_IO_MEDIA *Media;
FDC_BLK_IO_DEV *FdcDev;
UINTN BlockSize;
UINTN NumberOfBlocks;
UINTN BlockCount;
EFI_STATUS Status;
//
// EFI_STATUS CacheStatus;
//
EFI_LBA LBA0;
UINT8 *Pointer;
//
// Get the intrinsic block size
//
Media = This->Media;
BlockSize = Media->BlockSize;
FdcDev = FDD_BLK_IO_FROM_THIS (This);
if (Operation == WRITE) {
if (LBA == 0) {
FdcFreeCache (FdcDev);
}
}
//
// Check the Parameter is valid
//
if (Buffer == NULL) {
return EFI_INVALID_PARAMETER;
}
if (BufferSize == 0) {
return EFI_SUCCESS;
}
//
// Set the drive motor on
//
Status = MotorOn (FdcDev);
if (EFI_ERROR (Status)) {
return EFI_DEVICE_ERROR;
}
//
// Check to see if media can be detected
//
Status = DetectMedia (FdcDev);
if (EFI_ERROR (Status)) {
MotorOff (FdcDev);
FdcFreeCache (FdcDev);
return EFI_DEVICE_ERROR;
}
//
// Check to see if media is present
//
if (!(Media->MediaPresent)) {
MotorOff (FdcDev);
FdcFreeCache (FdcDev);
/*
if (FdcDev->Cache) {
gBS->FreePool (FdcDev->Cache);
FdcDev->Cache = NULL;
}
*/
return EFI_NO_MEDIA;
}
//
// Check to see if media has been changed
//
if (MediaId != Media->MediaId) {
MotorOff (FdcDev);
FdcFreeCache (FdcDev);
return EFI_MEDIA_CHANGED;
}
if (Operation == WRITE) {
if (Media->ReadOnly) {
MotorOff (FdcDev);
return EFI_WRITE_PROTECTED;
}
}
//
// Check the parameters for this read/write operation
//
if (BufferSize % BlockSize != 0) {
MotorOff (FdcDev);
return EFI_BAD_BUFFER_SIZE;
}
if (LBA > Media->LastBlock) {
MotorOff (FdcDev);
return EFI_INVALID_PARAMETER;
}
if (((BufferSize / BlockSize) + LBA - 1) > Media->LastBlock) {
MotorOff (FdcDev);
return EFI_INVALID_PARAMETER;
}
if (Operation == READ) {
//
// See if the data that is being read is already in the cache
//
if (FdcDev->Cache) {
if (LBA == 0 && BufferSize == BlockSize) {
MotorOff (FdcDev);
CopyMem ((UINT8 *) Buffer, (UINT8 *) FdcDev->Cache, BlockSize);
return EFI_SUCCESS;
}
}
}
//
// Set up Floppy Disk Controller
//
Status = Setup (FdcDev);
if (EFI_ERROR (Status)) {
MotorOff (FdcDev);
return EFI_DEVICE_ERROR;
}
NumberOfBlocks = BufferSize / BlockSize;
LBA0 = LBA;
Pointer = Buffer;
//
// read blocks in the same cylinder.
// in a cylinder , there are 18 * 2 = 36 blocks
//
BlockCount = GetTransferBlockCount (FdcDev, LBA, NumberOfBlocks);
while ((BlockCount != 0) && !EFI_ERROR (Status)) {
Status = ReadWriteDataSector (FdcDev, Buffer, LBA, BlockCount, Operation);
if (EFI_ERROR (Status)) {
MotorOff (FdcDev);
FddReset (FdcDev);
return EFI_DEVICE_ERROR;
}
LBA += BlockCount;
NumberOfBlocks -= BlockCount;
Buffer = (VOID *) ((UINTN) Buffer + BlockCount * BlockSize);
BlockCount = GetTransferBlockCount (FdcDev, LBA, NumberOfBlocks);
}
Buffer = Pointer;
//
// Turn the motor off
//
MotorOff (FdcDev);
if (Operation == READ) {
//
// Cache the data read
//
if (LBA0 == 0 && !FdcDev->Cache) {
FdcDev->Cache = AllocateCopyPool (BlockSize, Buffer);
}
}
return EFI_SUCCESS;
}
VOID
FdcFreeCache (
IN FDC_BLK_IO_DEV *FdcDev
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
FdcDev - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
if (FdcDev->Cache) {
gBS->FreePool (FdcDev->Cache);
FdcDev->Cache = NULL;
}
}

1551
IntelFrameworkModulePkg/Bus/Isa/IsaFloppy/Dxe/IsaFloppyCtrl.c Normal file
View File

File diff suppressed because it is too large Load Diff