[mirror_edk2.git] / PcAtChipsetPkg / Bus / Pci / IdeControllerDxe / IdeController.c

/** @file\r
  This driver module produces IDE_CONTROLLER_INIT protocol and will be used by \r
  IDE Bus driver to support platform dependent timing information. This driver\r
  is responsible for early initialization of IDE controller.\r
\r
  Copyright (c) 2008 - 2009 Intel Corporation. <BR>\r
  All rights reserved. This program and the accompanying materials                          \r
  are licensed and made available under the terms and conditions of the BSD License         \r
  which accompanies this distribution.  The full text of the license may be found at        \r
  http://opensource.org/licenses/bsd-license.php                                            \r
\r
  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     \r
  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             \r
\r
**/\r
\r
#include "IdeController.h"\r
\r
//\r
//  EFI_DRIVER_BINDING_PROTOCOL instance\r
//\r
EFI_DRIVER_BINDING_PROTOCOL gIdeControllerDriverBinding = {\r
  IdeControllerSupported,\r
  IdeControllerStart,\r
  IdeControllerStop,\r
  0xa,\r
  NULL,\r
  NULL\r
};\r
\r
//\r
//  EFI_IDE_CONTROLLER_PROVATE_DATA Template\r
//\r
EFI_IDE_CONTROLLER_INIT_PROTOCOL  gEfiIdeControllerInit = {\r
  IdeInitGetChannelInfo,\r
  IdeInitNotifyPhase,\r
  IdeInitSubmitData,\r
  IdeInitDisqualifyMode,\r
  IdeInitCalculateMode,\r
  IdeInitSetTiming,\r
  ICH_IDE_ENUMER_ALL,\r
  ICH_IDE_MAX_CHANNEL\r
};\r
\r
//\r
//  EFI_ATA_COLLECTIVE_MODE Template\r
//\r
EFI_ATA_COLLECTIVE_MODE  gEfiAtaCollectiveModeTemplate = {\r
  {           \r
    TRUE,                   // PioMode.Valid\r
    0                       // PioMode.Mode\r
  },\r
  {\r
    TRUE,                   // SingleWordDmaMode.Valid\r
    0\r
  },\r
  {\r
    FALSE,                  // MultiWordDmaMode.Valid\r
    0\r
  },\r
  {\r
    TRUE,                   // UdmaMode.Valid\r
    0                       // UdmaMode.Mode\r
  }\r
};\r
\r
EFI_STATUS\r
EFIAPI\r
InitializeIdeControllerDriver (\r
  IN EFI_HANDLE       ImageHandle,\r
  IN EFI_SYSTEM_TABLE *SystemTable\r
  )\r
/*++\r
  Routine Description:\r
  \r
    Chipset Ide Driver EntryPoint function. It follows the standard EFI driver \r
    model. It's called by StartImage() of DXE Core\r
    \r
  Argments:\r
  \r
    ImageHnadle  -- While the driver image loaded be the ImageLoader(), \r
                    an image handle is assigned to this driver binary, \r
                    all activities of the driver is tied to this ImageHandle\r
    *SystemTable -- A pointer to the system table, for all BS(Boo Services) and\r
                    RT(Runtime Services)\r
\r
  Retruns:\r
  \r
    Always call EfiLibInstallDriverBindingProtocol( ) and retrun the result\r
\r
--*/\r
{\r
  EFI_STATUS  Status;\r
\r
  //\r
  // Install driver model protocol(s).\r
  //\r
  Status = EfiLibInstallDriverBindingComponentName2 (\r
             ImageHandle,\r
             SystemTable,\r
             &gIdeControllerDriverBinding,\r
             ImageHandle,\r
             &gIdeControllerComponentName,\r
             &gIdeControllerComponentName2\r
             );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  return Status;\r
}\r
\r
EFI_STATUS\r
EFIAPI\r
IdeControllerSupported (\r
  IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
  IN EFI_HANDLE                  Controller,\r
  IN EFI_DEVICE_PATH_PROTOCOL    *RemainingDevicePath\r
  )\r
/*++\r
\r
  Routine Description:\r
  \r
  Register Driver Binding protocol for this driver.\r
  \r
  Arguments:\r
  \r
    This                 -- a pointer points to the Binding Protocol instance\r
    Controller           -- The handle of controller to be tested. \r
    *RemainingDevicePath -- A pointer to the device path. Ignored by device\r
                            driver but used by bus driver\r
\r
  Returns:\r
\r
    EFI_SUCCESS          -- Driver loaded.\r
    other                -- Driver not loaded.\r
--*/\r
{\r
  EFI_STATUS                Status;\r
  EFI_PCI_IO_PROTOCOL       *PciIo;\r
  UINT8                     PciClass;\r
  UINT8                     PciSubClass;\r
\r
  //\r
  // Attempt to Open PCI I/O Protocol\r
  //\r
  Status = gBS->OpenProtocol (\r
                  Controller,\r
                  &gEfiPciIoProtocolGuid,\r
                  (VOID **) &PciIo,\r
                  This->DriverBindingHandle,\r
                  Controller,\r
                  EFI_OPEN_PROTOCOL_BY_DRIVER\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Now further check the PCI header: Base class (offset 0x0B) and\r
  // Sub Class (offset 0x0A). This controller should be an Ide controller\r
  //\r
  Status = PciIo->Pci.Read (\r
                        PciIo,\r
                        EfiPciIoWidthUint8,\r
                        PCI_CLASSCODE_OFFSET + 2,\r
                        1,\r
                        &PciClass\r
                        );\r
  if (EFI_ERROR (Status)) {\r
    goto Done;\r
  }\r
\r
  Status = PciIo->Pci.Read (\r
                        PciIo,\r
                        EfiPciIoWidthUint8,\r
                        PCI_CLASSCODE_OFFSET + 1,\r
                        1,\r
                        &PciSubClass\r
                        );\r
  if (EFI_ERROR (Status)) {\r
    goto Done;\r
  }\r
\r
  //\r
  // Examine Ide PCI Configuration table fields\r
  //\r
  if ((PciClass != PCI_CLASS_MASS_STORAGE) || (PciSubClass != PCI_CLASS_MASS_STORAGE_IDE)) {\r
    Status = EFI_UNSUPPORTED;\r
  }\r
\r
Done:\r
  gBS->CloseProtocol (\r
        Controller,\r
        &gEfiPciIoProtocolGuid,\r
        This->DriverBindingHandle,\r
        Controller\r
        );\r
\r
  return Status;\r
}\r
\r
EFI_STATUS\r
EFIAPI\r
IdeControllerStart (\r
  IN EFI_DRIVER_BINDING_PROTOCOL    *This,\r
  IN EFI_HANDLE                     Controller,\r
  IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath\r
  )\r
/*++\r
\r
  Routine Description:\r
  \r
    This routine is called right after the .Supported() called and return \r
    EFI_SUCCESS. Notes: The supported protocols are checked but the Protocols\r
    are closed.\r
\r
  Arguments:\r
      \r
    This                 -- a pointer points to the Binding Protocol instance\r
    Controller           -- The handle of controller to be tested. Parameter\r
                            passed by the caller\r
    *RemainingDevicePath -- A pointer to the device path. Should be ignored by\r
                            device driver\r
--*/\r
{\r
  EFI_STATUS           Status;\r
  EFI_PCI_IO_PROTOCOL  *PciIo;\r
\r
  //\r
  // Now test and open the EfiPciIoProtocol\r
  //\r
  Status = gBS->OpenProtocol (\r
                  Controller,\r
                  &gEfiPciIoProtocolGuid,\r
                  (VOID **) &PciIo,\r
                  This->DriverBindingHandle,\r
                  Controller,\r
                  EFI_OPEN_PROTOCOL_BY_DRIVER\r
                  );\r
  //\r
  // Status == EFI_SUCCESS - A normal execution flow, SUCCESS and the program proceeds.\r
  // Status == ALREADY_STARTED - A non-zero Status code returned. It indicates\r
  //           that the protocol has been opened and should be treated as a\r
  //           normal condition and the program proceeds. The Protocol will not\r
  //           opened 'again' by this call.\r
  // Status != ALREADY_STARTED - Error status, terminate program execution\r
  //\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Install IDE_CONTROLLER_INIT protocol \r
  //\r
  return gBS->InstallMultipleProtocolInterfaces (\r
                &Controller,\r
                &gEfiIdeControllerInitProtocolGuid, &gEfiIdeControllerInit,\r
                NULL\r
                );\r
}\r
\r
EFI_STATUS\r
EFIAPI\r
IdeControllerStop (\r
  IN  EFI_DRIVER_BINDING_PROTOCOL     *This,\r
  IN  EFI_HANDLE                      Controller,\r
  IN  UINTN                           NumberOfChildren,\r
  IN  EFI_HANDLE                      *ChildHandleBuffer\r
  )\r
/*++\r
  \r
  Routine Description:\r
    Stop this driver on Controller Handle. \r
\r
  Arguments:\r
    This              - Protocol instance pointer.\r
    Controller        - Handle of device to stop driver on \r
    NumberOfChildren  - Not used\r
    ChildHandleBuffer - Not used\r
\r
  Returns:\r
    EFI_SUCCESS       - This driver is removed DeviceHandle\r
    other             - This driver was not removed from this device\r
  \r
--*/\r
{\r
  EFI_STATUS                        Status;\r
  EFI_IDE_CONTROLLER_INIT_PROTOCOL  *IdeControllerInit;\r
\r
  //\r
  // Open the produced protocol\r
  //\r
  Status = gBS->OpenProtocol (\r
                  Controller,\r
                  &gEfiIdeControllerInitProtocolGuid,\r
                  (VOID **) &IdeControllerInit,\r
                  This->DriverBindingHandle,\r
                  Controller,\r
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
                  );\r
  if (EFI_ERROR (Status)) {\r
     return EFI_UNSUPPORTED;\r
  }\r
\r
  //\r
  // Make sure the protocol was produced by this driver\r
  //\r
  if (IdeControllerInit != &gEfiIdeControllerInit) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  //\r
  // Uninstall the IDE Controller Init Protocol\r
  //\r
  Status = gBS->UninstallMultipleProtocolInterfaces (\r
                  Controller,\r
                  &gEfiIdeControllerInitProtocolGuid, &gEfiIdeControllerInit,\r
                  NULL\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Close protocols opened by Ide controller driver\r
  //\r
  return gBS->CloseProtocol (\r
                Controller,\r
                &gEfiPciIoProtocolGuid,\r
                This->DriverBindingHandle,\r
                Controller\r
                );\r
}\r
\r
//\r
// Interface functions of IDE_CONTROLLER_INIT protocol\r
//\r
EFI_STATUS\r
EFIAPI\r
IdeInitGetChannelInfo (\r
  IN   EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,\r
  IN   UINT8                            Channel,\r
  OUT  BOOLEAN                          *Enabled,\r
  OUT  UINT8                            *MaxDevices\r
  )\r
/*++\r
Routine Description:\r
\r
  This function can be used to obtain information about a specified channel. \r
  It's usually used by IDE Bus driver during enumeration process.\r
\r
Arguments:\r
\r
  This       -- the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.\r
  Channel    -- Channel number (0 based, either 0 or 1)\r
  Enabled    -- TRUE if the channel is enabled. If the channel is disabled, \r
                then it will no be enumerated.\r
  MaxDevices -- The Max number of IDE devices that the bus driver can expect\r
                on this channel. For ATA/ATAPI, this number is either 1 or 2.\r
\r
Returns:\r
  EFI_STATUS \r
\r
--*/\r
{\r
  //\r
  // Channel number (0 based, either 0 or 1)\r
  //\r
  if (Channel < ICH_IDE_MAX_CHANNEL) {\r
    *Enabled    = TRUE;\r
    *MaxDevices = ICH_IDE_MAX_DEVICES;\r
    return EFI_SUCCESS;\r
  }\r
\r
  *Enabled = FALSE;\r
  return EFI_INVALID_PARAMETER;\r
}\r
\r
\r
EFI_STATUS\r
EFIAPI\r
IdeInitNotifyPhase (\r
  IN  EFI_IDE_CONTROLLER_INIT_PROTOCOL   *This,\r
  IN  EFI_IDE_CONTROLLER_ENUM_PHASE      Phase,\r
  IN  UINT8                              Channel\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function is called by IdeBus driver before executing certain actions. \r
  This allows IDE Controller Init to prepare for each action.\r
\r
Arguments:\r
\r
  This     -- the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.\r
  Phase    -- phase indicator defined by IDE_CONTROLLER_INIT protocol\r
  Channel  -- Channel number (0 based, either 0 or 1)\r
\r
Returns:\r
    \r
--*/\r
{\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
EFIAPI\r
IdeInitSubmitData (\r
  IN  EFI_IDE_CONTROLLER_INIT_PROTOCOL    *This,\r
  IN  UINT8                               Channel,\r
  IN  UINT8                               Device,\r
  IN  EFI_IDENTIFY_DATA                   *IdentifyData\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function is called by IdeBus driver to submit EFI_IDENTIFY_DATA data structure\r
  obtained from IDE deivce. This structure is used to set IDE timing\r
\r
Arguments:\r
\r
  This         -- the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.\r
  Channel      -- IDE channel number (0 based, either 0 or 1)\r
  Device       -- IDE device number\r
  IdentifyData -- A pointer to EFI_IDENTIFY_DATA data structure\r
\r
Returns:\r
    \r
--*/\r
{\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
EFIAPI\r
IdeInitDisqualifyMode (\r
  IN  EFI_IDE_CONTROLLER_INIT_PROTOCOL    *This,\r
  IN  UINT8                               Channel,\r
  IN  UINT8                               Device,\r
  IN  EFI_ATA_COLLECTIVE_MODE             *BadModes\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function is called by IdeBus driver to disqualify unsupported operation\r
  mode on specfic IDE device\r
\r
Arguments:\r
\r
  This     -- the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.\r
  Channel  -- IDE channel number (0 based, either 0 or 1)\r
  Device   -- IDE device number\r
  BadModes -- Operation mode indicator\r
\r
Returns:\r
    \r
--*/\r
{\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
EFIAPI\r
IdeInitCalculateMode (\r
  IN  EFI_IDE_CONTROLLER_INIT_PROTOCOL       *This,\r
  IN  UINT8                                  Channel,\r
  IN  UINT8                                  Device,\r
  OUT EFI_ATA_COLLECTIVE_MODE                **SupportedModes\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function is called by IdeBus driver to calculate the best operation mode\r
  supported by specific IDE device\r
\r
Arguments:\r
\r
  This           -- the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.\r
  Channel        -- IDE channel number (0 based, either 0 or 1)\r
  Device         -- IDE device number\r
  SupportedModes -- Modes collection supported by IDE device\r
\r
Returns:\r
    \r
--*/\r
{\r
  if (Channel >= ICH_IDE_MAX_CHANNEL || Device >= ICH_IDE_MAX_DEVICES) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  *SupportedModes = AllocateCopyPool (sizeof (EFI_ATA_COLLECTIVE_MODE), &gEfiAtaCollectiveModeTemplate);\r
  if (*SupportedModes == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
EFI_STATUS\r
EFIAPI\r
IdeInitSetTiming (\r
  IN  EFI_IDE_CONTROLLER_INIT_PROTOCOL    *This,\r
  IN  UINT8                               Channel,\r
  IN  UINT8                               Device,\r
  IN  EFI_ATA_COLLECTIVE_MODE             *Modes\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  This function is called by IdeBus driver to set appropriate timing on IDE\r
  controller according supported operation mode\r
\r
Arguments:\r
\r
  This           -- the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.\r
  Channel        -- IDE channel number (0 based, either 0 or 1)\r
  Device         -- IDE device number\r
\r
Returns:\r
    \r
--*/\r
{\r
  return EFI_SUCCESS;\r
}\r
Commit	Line	Data
a1f11f75	1	/** @file\r
	2	This driver module produces IDE_CONTROLLER_INIT protocol and will be used by \r
	3	IDE Bus driver to support platform dependent timing information. This driver\r
	4	is responsible for early initialization of IDE controller.\r
	5	\r
	6	Copyright (c) 2008 - 2009 Intel Corporation. <BR>\r
	7	All rights reserved. This program and the accompanying materials \r
	8	are licensed and made available under the terms and conditions of the BSD License \r
	9	which accompanies this distribution. The full text of the license may be found at \r
	10	http://opensource.org/licenses/bsd-license.php \r
	11	\r
	12	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
	13	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. \r
	14	\r
	15	**/\r
	16	\r
	17	#include "IdeController.h"\r
	18	\r
	19	//\r
	20	// EFI_DRIVER_BINDING_PROTOCOL instance\r
	21	//\r
	22	EFI_DRIVER_BINDING_PROTOCOL gIdeControllerDriverBinding = {\r
	23	IdeControllerSupported,\r
	24	IdeControllerStart,\r
	25	IdeControllerStop,\r
	26	0xa,\r
	27	NULL,\r
	28	NULL\r
	29	};\r
	30	\r
	31	//\r
	32	// EFI_IDE_CONTROLLER_PROVATE_DATA Template\r
	33	//\r
	34	EFI_IDE_CONTROLLER_INIT_PROTOCOL gEfiIdeControllerInit = {\r
	35	IdeInitGetChannelInfo,\r
	36	IdeInitNotifyPhase,\r
	37	IdeInitSubmitData,\r
	38	IdeInitDisqualifyMode,\r
	39	IdeInitCalculateMode,\r
	40	IdeInitSetTiming,\r
	41	ICH_IDE_ENUMER_ALL,\r
	42	ICH_IDE_MAX_CHANNEL\r
	43	};\r
	44	\r
	45	//\r
	46	// EFI_ATA_COLLECTIVE_MODE Template\r
	47	//\r
	48	EFI_ATA_COLLECTIVE_MODE gEfiAtaCollectiveModeTemplate = {\r
	49	{ \r
	50	TRUE, // PioMode.Valid\r
	51	0 // PioMode.Mode\r
	52	},\r
	53	{\r
	54	TRUE, // SingleWordDmaMode.Valid\r
	55	0\r
	56	},\r
	57	{\r
	58	FALSE, // MultiWordDmaMode.Valid\r
	59	0\r
	60	},\r
	61	{\r
	62	TRUE, // UdmaMode.Valid\r
	63	0 // UdmaMode.Mode\r
	64	}\r
65	};\r
66	\r
67	EFI_STATUS\r
68	EFIAPI\r
69	InitializeIdeControllerDriver (\r
70	IN EFI_HANDLE ImageHandle,\r
71	IN EFI_SYSTEM_TABLE *SystemTable\r
72	)\r
73	/*++\r
74	Routine Description:\r
75	\r
76	Chipset Ide Driver EntryPoint function. It follows the standard EFI driver \r
77	model. It's called by StartImage() of DXE Core\r
78	\r
79	Argments:\r
80	\r
81	ImageHnadle -- While the driver image loaded be the ImageLoader(), \r
82	an image handle is assigned to this driver binary, \r
83	all activities of the driver is tied to this ImageHandle\r
84	*SystemTable -- A pointer to the system table, for all BS(Boo Services) and\r
85	RT(Runtime Services)\r
86	\r
87	Retruns:\r
88	\r
89	Always call EfiLibInstallDriverBindingProtocol( ) and retrun the result\r
90	\r
91	--*/\r
92	{\r
93	EFI_STATUS Status;\r
94	\r
95	//\r
96	// Install driver model protocol(s).\r
97	//\r
98	Status = EfiLibInstallDriverBindingComponentName2 (\r
99	ImageHandle,\r
100	SystemTable,\r
101	&gIdeControllerDriverBinding,\r
102	ImageHandle,\r
103	&gIdeControllerComponentName,\r
104	&gIdeControllerComponentName2\r
105	);\r
106	ASSERT_EFI_ERROR (Status);\r
107	\r
108	return Status;\r
109	}\r
110	\r
111	EFI_STATUS\r
112	EFIAPI\r
113	IdeControllerSupported (\r
114	IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
115	IN EFI_HANDLE Controller,\r
116	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath\r
117	)\r
118	/*++\r
119	\r
120	Routine Description:\r
121	\r
122	Register Driver Binding protocol for this driver.\r
123	\r
124	Arguments:\r
125	\r
126	This -- a pointer points to the Binding Protocol instance\r
127	Controller -- The handle of controller to be tested. \r
128	*RemainingDevicePath -- A pointer to the device path. Ignored by device\r
129	driver but used by bus driver\r
130	\r
131	Returns:\r
132	\r
133	EFI_SUCCESS -- Driver loaded.\r
134	other -- Driver not loaded.\r
135	--*/\r
136	{\r
137	EFI_STATUS Status;\r
138	EFI_PCI_IO_PROTOCOL *PciIo;\r
139	UINT8 PciClass;\r
140	UINT8 PciSubClass;\r
141	\r
142	//\r
143	// Attempt to Open PCI I/O Protocol\r
144	//\r
145	Status = gBS->OpenProtocol (\r
146	Controller,\r
147	&gEfiPciIoProtocolGuid,\r
148	(VOID **) &PciIo,\r
149	This->DriverBindingHandle,\r
150	Controller,\r
151	EFI_OPEN_PROTOCOL_BY_DRIVER\r
152	);\r
153	if (EFI_ERROR (Status)) {\r
154	return Status;\r
155	}\r
156	\r
157	//\r
158	// Now further check the PCI header: Base class (offset 0x0B) and\r
159	// Sub Class (offset 0x0A). This controller should be an Ide controller\r
160	//\r
161	Status = PciIo->Pci.Read (\r
162	PciIo,\r
163	EfiPciIoWidthUint8,\r
164	PCI_CLASSCODE_OFFSET + 2,\r
165	1,\r
166	&PciClass\r
167	);\r
168	if (EFI_ERROR (Status)) {\r
169	goto Done;\r
170	}\r
171	\r
172	Status = PciIo->Pci.Read (\r
173	PciIo,\r
174	EfiPciIoWidthUint8,\r
175	PCI_CLASSCODE_OFFSET + 1,\r
176	1,\r
177	&PciSubClass\r
178	);\r
179	if (EFI_ERROR (Status)) {\r
180	goto Done;\r
181	}\r
182	\r
183	//\r
184	// Examine Ide PCI Configuration table fields\r
185	//\r
186	if ((PciClass != PCI_CLASS_MASS_STORAGE) \|\| (PciSubClass != PCI_CLASS_MASS_STORAGE_IDE)) {\r
187	Status = EFI_UNSUPPORTED;\r
188	}\r
189	\r
190	Done:\r
191	gBS->CloseProtocol (\r
192	Controller,\r
193	&gEfiPciIoProtocolGuid,\r
194	This->DriverBindingHandle,\r
195	Controller\r
196	);\r
197	\r
198	return Status;\r
199	}\r
200	\r
201	EFI_STATUS\r
202	EFIAPI\r
203	IdeControllerStart (\r
204	IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
205	IN EFI_HANDLE Controller,\r
206	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath\r
207	)\r
208	/*++\r
209	\r
210	Routine Description:\r
211	\r
212	This routine is called right after the .Supported() called and return \r
213	EFI_SUCCESS. Notes: The supported protocols are checked but the Protocols\r
214	are closed.\r
215	\r
216	Arguments:\r
217	\r
218	This -- a pointer points to the Binding Protocol instance\r
219	Controller -- The handle of controller to be tested. Parameter\r
220	passed by the caller\r
221	*RemainingDevicePath -- A pointer to the device path. Should be ignored by\r
222	device driver\r
223	--*/\r
224	{\r
225	EFI_STATUS Status;\r
226	EFI_PCI_IO_PROTOCOL *PciIo;\r
227	\r
228	//\r
229	// Now test and open the EfiPciIoProtocol\r
230	//\r
231	Status = gBS->OpenProtocol (\r
232	Controller,\r
233	&gEfiPciIoProtocolGuid,\r
234	(VOID **) &PciIo,\r
235	This->DriverBindingHandle,\r
236	Controller,\r
237	EFI_OPEN_PROTOCOL_BY_DRIVER\r
238	);\r
239	//\r
240	// Status == EFI_SUCCESS - A normal execution flow, SUCCESS and the program proceeds.\r
241	// Status == ALREADY_STARTED - A non-zero Status code returned. It indicates\r
242	// that the protocol has been opened and should be treated as a\r
243	// normal condition and the program proceeds. The Protocol will not\r
244	// opened 'again' by this call.\r
245	// Status != ALREADY_STARTED - Error status, terminate program execution\r
246	//\r
247	if (EFI_ERROR (Status)) {\r
248	return Status;\r
249	}\r
250	\r
251	//\r
252	// Install IDE_CONTROLLER_INIT protocol \r
253	//\r
254	return gBS->InstallMultipleProtocolInterfaces (\r
255	&Controller,\r
256	&gEfiIdeControllerInitProtocolGuid, &gEfiIdeControllerInit,\r
257	NULL\r
258	);\r
259	}\r
260	\r
261	EFI_STATUS\r
262	EFIAPI\r
263	IdeControllerStop (\r
264	IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
265	IN EFI_HANDLE Controller,\r
266	IN UINTN NumberOfChildren,\r
267	IN EFI_HANDLE *ChildHandleBuffer\r
268	)\r
269	/*++\r
270	\r
271	Routine Description:\r
272	Stop this driver on Controller Handle. \r
273	\r
274	Arguments:\r
275	This - Protocol instance pointer.\r
276	Controller - Handle of device to stop driver on \r
277	NumberOfChildren - Not used\r
278	ChildHandleBuffer - Not used\r
279	\r
280	Returns:\r
281	EFI_SUCCESS - This driver is removed DeviceHandle\r
282	other - This driver was not removed from this device\r
283	\r
284	--*/\r
285	{\r
286	EFI_STATUS Status;\r
287	EFI_IDE_CONTROLLER_INIT_PROTOCOL *IdeControllerInit;\r
288	\r
289	//\r
290	// Open the produced protocol\r
291	//\r
292	Status = gBS->OpenProtocol (\r
293	Controller,\r
294	&gEfiIdeControllerInitProtocolGuid,\r
295	(VOID **) &IdeControllerInit,\r
296	This->DriverBindingHandle,\r
297	Controller,\r
298	EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
299	);\r
300	if (EFI_ERROR (Status)) {\r
301	return EFI_UNSUPPORTED;\r
302	}\r
303	\r
304	//\r
305	// Make sure the protocol was produced by this driver\r
306	//\r
307	if (IdeControllerInit != &gEfiIdeControllerInit) {\r
308	return EFI_UNSUPPORTED;\r
309	}\r
310	\r
311	//\r
312	// Uninstall the IDE Controller Init Protocol\r
313	//\r
314	Status = gBS->UninstallMultipleProtocolInterfaces (\r
315	Controller,\r
316	&gEfiIdeControllerInitProtocolGuid, &gEfiIdeControllerInit,\r
317	NULL\r
318	);\r
319	if (EFI_ERROR (Status)) {\r
320	return Status;\r
321	}\r
322	\r
323	//\r
324	// Close protocols opened by Ide controller driver\r
325	//\r
326	return gBS->CloseProtocol (\r
327	Controller,\r
328	&gEfiPciIoProtocolGuid,\r
329	This->DriverBindingHandle,\r
330	Controller\r
331	);\r
332	}\r
333	\r
334	//\r
335	// Interface functions of IDE_CONTROLLER_INIT protocol\r
336	//\r
337	EFI_STATUS\r
338	EFIAPI\r
339	IdeInitGetChannelInfo (\r
340	IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,\r
341	IN UINT8 Channel,\r
342	OUT BOOLEAN *Enabled,\r
343	OUT UINT8 *MaxDevices\r
344	)\r
345	/*++\r
346	Routine Description:\r
347	\r
348	This function can be used to obtain information about a specified channel. \r
349	It's usually used by IDE Bus driver during enumeration process.\r
350	\r
351	Arguments:\r
352	\r
353	This -- the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.\r
354	Channel -- Channel number (0 based, either 0 or 1)\r
355	Enabled -- TRUE if the channel is enabled. If the channel is disabled, \r
356	then it will no be enumerated.\r
357	MaxDevices -- The Max number of IDE devices that the bus driver can expect\r
358	on this channel. For ATA/ATAPI, this number is either 1 or 2.\r
359	\r
360	Returns:\r
361	EFI_STATUS \r
362	\r
363	--*/\r
364	{\r
365	//\r
366	// Channel number (0 based, either 0 or 1)\r
367	//\r
368	if (Channel < ICH_IDE_MAX_CHANNEL) {\r
369	*Enabled = TRUE;\r
370	*MaxDevices = ICH_IDE_MAX_DEVICES;\r
371	return EFI_SUCCESS;\r
372	}\r
373	\r
374	*Enabled = FALSE;\r
375	return EFI_INVALID_PARAMETER;\r
376	}\r
377	\r
378	\r
379	EFI_STATUS\r
380	EFIAPI\r
381	IdeInitNotifyPhase (\r
382	IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,\r
383	IN EFI_IDE_CONTROLLER_ENUM_PHASE Phase,\r
384	IN UINT8 Channel\r
385	)\r
386	/*++\r
387	\r
388	Routine Description:\r
389	\r
390	This function is called by IdeBus driver before executing certain actions. \r
391	This allows IDE Controller Init to prepare for each action.\r
392	\r
393	Arguments:\r
394	\r
395	This -- the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.\r
396	Phase -- phase indicator defined by IDE_CONTROLLER_INIT protocol\r
397	Channel -- Channel number (0 based, either 0 or 1)\r
398	\r
399	Returns:\r
400	\r
401	--*/\r
402	{\r
403	return EFI_SUCCESS;\r
404	}\r
405	\r
406	EFI_STATUS\r
407	EFIAPI\r
408	IdeInitSubmitData (\r
409	IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,\r
410	IN UINT8 Channel,\r
411	IN UINT8 Device,\r
412	IN EFI_IDENTIFY_DATA *IdentifyData\r
413	)\r
414	/*++\r
415	\r
416	Routine Description:\r
417	\r
418	This function is called by IdeBus driver to submit EFI_IDENTIFY_DATA data structure\r
419	obtained from IDE deivce. This structure is used to set IDE timing\r
420	\r
421	Arguments:\r
422	\r
423	This -- the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.\r
424	Channel -- IDE channel number (0 based, either 0 or 1)\r
425	Device -- IDE device number\r
426	IdentifyData -- A pointer to EFI_IDENTIFY_DATA data structure\r
427	\r
428	Returns:\r
429	\r
430	--*/\r
431	{\r
432	return EFI_SUCCESS;\r
433	}\r
434	\r
435	EFI_STATUS\r
436	EFIAPI\r
437	IdeInitDisqualifyMode (\r
438	IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,\r
439	IN UINT8 Channel,\r
440	IN UINT8 Device,\r
441	IN EFI_ATA_COLLECTIVE_MODE *BadModes\r
442	)\r
443	/*++\r
444	\r
445	Routine Description:\r
446	\r
447	This function is called by IdeBus driver to disqualify unsupported operation\r
448	mode on specfic IDE device\r
449	\r
450	Arguments:\r
451	\r
452	This -- the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.\r
453	Channel -- IDE channel number (0 based, either 0 or 1)\r
454	Device -- IDE device number\r
455	BadModes -- Operation mode indicator\r
456	\r
457	Returns:\r
458	\r
459	--*/\r
460	{\r
461	return EFI_SUCCESS;\r
462	}\r
463	\r
464	EFI_STATUS\r
465	EFIAPI\r
466	IdeInitCalculateMode (\r
467	IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,\r
468	IN UINT8 Channel,\r
469	IN UINT8 Device,\r
470	OUT EFI_ATA_COLLECTIVE_MODE **SupportedModes\r
471	)\r
472	/*++\r
473	\r
474	Routine Description:\r
475	\r
476	This function is called by IdeBus driver to calculate the best operation mode\r
477	supported by specific IDE device\r
478	\r
479	Arguments:\r
480	\r
481	This -- the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.\r
482	Channel -- IDE channel number (0 based, either 0 or 1)\r
483	Device -- IDE device number\r
484	SupportedModes -- Modes collection supported by IDE device\r
485	\r
486	Returns:\r
487	\r
488	--*/\r
489	{\r
490	if (Channel >= ICH_IDE_MAX_CHANNEL \|\| Device >= ICH_IDE_MAX_DEVICES) {\r
491	return EFI_INVALID_PARAMETER;\r
492	}\r
493	\r
494	*SupportedModes = AllocateCopyPool (sizeof (EFI_ATA_COLLECTIVE_MODE), &gEfiAtaCollectiveModeTemplate);\r
495	if (*SupportedModes == NULL) {\r
496	return EFI_OUT_OF_RESOURCES;\r
497	}\r
498	\r
499	return EFI_SUCCESS;\r
500	}\r
501	\r
502	\r
503	EFI_STATUS\r
504	EFIAPI\r
505	IdeInitSetTiming (\r
506	IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,\r
507	IN UINT8 Channel,\r
508	IN UINT8 Device,\r
509	IN EFI_ATA_COLLECTIVE_MODE *Modes\r
510	)\r
511	/*++\r
512	\r
513	Routine Description:\r
514	\r
515	This function is called by IdeBus driver to set appropriate timing on IDE\r
516	controller according supported operation mode\r
517	\r
518	Arguments:\r
519	\r
520	This -- the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.\r
521	Channel -- IDE channel number (0 based, either 0 or 1)\r
522	Device -- IDE device number\r
523	\r
524	Returns:\r
525	\r
526	--*/\r
527	{\r
528	return EFI_SUCCESS;\r
529	}\r