]> git.proxmox.com Git - mirror_edk2.git/blame - EdkModulePkg/Bus/Pci/IdeBus/Dxe/idebus.c
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Obsoleted by new schema and new build tools.
[mirror_edk2.git] / EdkModulePkg / Bus / Pci / IdeBus / Dxe / idebus.c
CommitLineData
ed72955c 1/** @file\r
2 Copyright (c) 2006, Intel Corporation \r
3 All rights reserved. This program and the accompanying materials \r
4 are licensed and made available under the terms and conditions of the BSD License \r
5 which accompanies this distribution. The full text of the license may be found at \r
6 http://opensource.org/licenses/bsd-license.php \r
878ddf1f 7\r
ed72955c 8 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
9 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. \r
878ddf1f 10\r
ed72955c 11 @par Revision Reference:\r
878ddf1f 12 This module is modified from DXE\IDE module for Ide Contriller Init support\r
13\r
ed72955c 14**/\r
878ddf1f 15\r
16#include "idebus.h"\r
17\r
18#define PCI_CLASS_MASS_STORAGE 0x01\r
19#define PCI_SUB_CLASS_IDE 0x01\r
20\r
21\r
22//\r
23// IDE Bus Driver Binding Protocol Instance\r
24//\r
25EFI_DRIVER_BINDING_PROTOCOL gIDEBusDriverBinding = {\r
26 IDEBusDriverBindingSupported,\r
27 IDEBusDriverBindingStart,\r
28 IDEBusDriverBindingStop,\r
29 0x10,\r
30 NULL,\r
31 NULL\r
32};\r
33\r
34//\r
35// ***********************************************************************************\r
36// IDEBusDriverBindingSupported\r
37// ***********************************************************************************\r
38//\r
ed72955c 39/**\r
40 Register Driver Binding protocol for this driver.\r
41\r
42 @param[in] This -- A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.\r
43 @param[in] ControllerHandle -- The handle of the controller to test.\r
44 @param[in] RemainingDevicePath -- A pointer to the remaining portion of a device path.\r
45\r
46 @retval EFI_SUCCESS Driver loaded.\r
47 @retval other Driver not loaded.\r
48\r
49**/\r
878ddf1f 50EFI_STATUS\r
51EFIAPI\r
52IDEBusDriverBindingSupported (\r
53 IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
54 IN EFI_HANDLE Controller,\r
55 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath\r
56 )\r
878ddf1f 57// TODO: Controller - add argument and description to function comment\r
58// TODO: EFI_UNSUPPORTED - add return value to function comment\r
59{\r
60 EFI_STATUS Status;\r
61 EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath;\r
62 EFI_DEV_PATH *Node;\r
63 EFI_IDE_CONTROLLER_INIT_PROTOCOL *IdeInit;\r
64\r
65 if (RemainingDevicePath != NULL) {\r
66 Node = (EFI_DEV_PATH *) RemainingDevicePath;\r
67 if (Node->DevPath.Type != MESSAGING_DEVICE_PATH ||\r
68 Node->DevPath.SubType != MSG_ATAPI_DP ||\r
69 DevicePathNodeLength(&Node->DevPath) != sizeof(ATAPI_DEVICE_PATH)) {\r
70 return EFI_UNSUPPORTED;\r
71 }\r
72 }\r
73\r
74 //\r
75 // Open the IO Abstraction(s) needed to perform the supported test\r
76 //\r
77 Status = gBS->OpenProtocol (\r
78 Controller,\r
79 &gEfiDevicePathProtocolGuid,\r
80 (VOID **) &ParentDevicePath,\r
81 This->DriverBindingHandle,\r
82 Controller,\r
83 EFI_OPEN_PROTOCOL_BY_DRIVER\r
84 );\r
85 if (Status == EFI_ALREADY_STARTED) {\r
86 return EFI_SUCCESS;\r
87 }\r
88\r
89 if (EFI_ERROR (Status)) {\r
90 return Status;\r
91 }\r
92 \r
93 //\r
94 // Clsoe protocol, don't use device path protocol in the .Support() function\r
95 //\r
96 gBS->CloseProtocol (\r
97 Controller,\r
98 &gEfiDevicePathProtocolGuid,\r
99 This->DriverBindingHandle,\r
100 Controller\r
101 );\r
102\r
103 //\r
104 // Verify the Ide Controller Init Protocol, which installed by the\r
105 // IdeController module.\r
106 // Note 1: PciIo protocol has been opened BY_DRIVER by ide_init, so We can't\r
107 // open BY_DRIVER here) That's why we don't check pciio protocol\r
108 // Note 2: ide_init driver check ide controller's pci config space, so we dont\r
109 // check here any more to save code size\r
110 //\r
111 Status = gBS->OpenProtocol (\r
112 Controller,\r
113 &gEfiIdeControllerInitProtocolGuid,\r
114 (VOID **) &IdeInit,\r
115 This->DriverBindingHandle,\r
116 Controller,\r
117 EFI_OPEN_PROTOCOL_BY_DRIVER\r
118 );\r
119\r
120 if (Status == EFI_ALREADY_STARTED) {\r
121 return EFI_SUCCESS;\r
122 }\r
123\r
124 //\r
125 // If protocols were opened normally, closed it\r
126 //\r
127 gBS->CloseProtocol (\r
128 Controller,\r
129 &gEfiIdeControllerInitProtocolGuid,\r
130 This->DriverBindingHandle,\r
131 Controller\r
132 );\r
133\r
134 return Status;\r
135}\r
136\r
137//\r
138// ***********************************************************************************\r
139// IDEBusDriverBindingStart\r
140// ***********************************************************************************\r
141//\r
ed72955c 142/**\r
143 Start this driver on Controller by detecting all disks and installing \r
144 BlockIo protocol on them.\r
145\r
146 @param This Protocol instance pointer.\r
147 @param Controller Handle of device to bind driver to.\r
148 @param RemainingDevicePath Not used, always produce all possible children.\r
149\r
150 @retval EFI_SUCCESS This driver is added to ControllerHandle.\r
151 @retval EFI_ALREADY_STARTED This driver is already running on ControllerHandle.\r
152 @retval other This driver does not support this device.\r
153\r
154**/\r
878ddf1f 155EFI_STATUS\r
156EFIAPI\r
157IDEBusDriverBindingStart (\r
158 IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
159 IN EFI_HANDLE Controller,\r
160 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath\r
161 )\r
878ddf1f 162{\r
163 EFI_STATUS Status;\r
164 EFI_STATUS SavedStatus;\r
165 EFI_PCI_IO_PROTOCOL *PciIo;\r
166 EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath;\r
167 EFI_DEV_PATH *Node;\r
168 UINT8 IdeChannel;\r
169 UINT8 BeginningIdeChannel;\r
170 UINT8 EndIdeChannel;\r
171 UINT8 IdeDevice;\r
172 UINT8 BeginningIdeDevice;\r
173 UINT8 EndIdeDevice;\r
174 IDE_BLK_IO_DEV *IdeBlkIoDevice[IdeMaxChannel][IdeMaxDevice];\r
175 IDE_BLK_IO_DEV *IdeBlkIoDevicePtr;\r
176 IDE_REGISTERS_BASE_ADDR IdeRegsBaseAddr[IdeMaxChannel];\r
177 ATA_TRANSFER_MODE TransferMode;\r
178 ATA_DRIVE_PARMS DriveParameters;\r
179 EFI_DEV_PATH NewNode;\r
180 UINT8 ConfigurationOptions;\r
181 UINT16 CommandBlockBaseAddr;\r
182 UINT16 ControlBlockBaseAddr;\r
183 UINTN DataSize;\r
184 UINT32 Attributes;\r
185 IDE_BUS_DRIVER_PRIVATE_DATA *IdeBusDriverPrivateData;\r
186\r
187 //\r
188 // Local variables declaration for IdeControllerInit support\r
189 //\r
190 EFI_IDE_CONTROLLER_INIT_PROTOCOL *IdeInit;\r
191 BOOLEAN EnumAll;\r
192 BOOLEAN ChannelEnabled;\r
193 UINT8 ChannelCount;\r
194 UINT8 MaxDevices;\r
195 EFI_IDENTIFY_DATA IdentifyData;\r
196 EFI_ATA_COLLECTIVE_MODE *SupportedModes;\r
197\r
198 IdeBusDriverPrivateData = NULL;\r
199 SupportedModes = NULL;\r
200\r
201 //\r
202 // Perform IdeBus initialization\r
203 //\r
204 Status = gBS->OpenProtocol (\r
205 Controller,\r
206 &gEfiDevicePathProtocolGuid,\r
207 (VOID **) &ParentDevicePath,\r
208 This->DriverBindingHandle,\r
209 Controller,\r
210 EFI_OPEN_PROTOCOL_BY_DRIVER\r
211 );\r
212 if ((EFI_ERROR (Status)) && (Status != EFI_ALREADY_STARTED)) {\r
213 return Status;\r
214 }\r
215 \r
216 //\r
217 // Now open the IDE_CONTROLLER_INIT protocol. Step7.1\r
218 //\r
219 Status = gBS->OpenProtocol (\r
220 Controller,\r
221 &gEfiIdeControllerInitProtocolGuid,\r
222 (VOID **) &IdeInit,\r
223 This->DriverBindingHandle,\r
224 Controller,\r
225 EFI_OPEN_PROTOCOL_BY_DRIVER\r
226 );\r
227\r
228 //\r
229 // The following OpenProtocol function with _GET_PROTOCOL attribute and\r
230 // will not return EFI_ALREADY_STARTED, so save it for now\r
231 //\r
232 SavedStatus = Status;\r
233\r
234 if ((EFI_ERROR (Status)) && (Status != EFI_ALREADY_STARTED)) {\r
235 DEBUG ((EFI_D_ERROR, "Open Init, Status=%x", Status));\r
236 //\r
237 // open protocol is not SUCCESS or not ALREADY_STARTED, error exit\r
238 //\r
239 goto ErrorExit;\r
240 }\r
241\r
242 //\r
243 // Save Enumall and ChannelCount. Step7.2\r
244 //\r
245 EnumAll = IdeInit->EnumAll;\r
246 ChannelCount = IdeInit->ChannelCount;\r
247\r
248 //\r
249 // Consume PCI I/O protocol. Note that the OpenProtocol with _GET_PROTOCOL\r
250 // attribute will not return EFI_ALREADY_STARTED\r
251 //\r
252 Status = gBS->OpenProtocol (\r
253 Controller,\r
254 &gEfiPciIoProtocolGuid,\r
255 (VOID **) &PciIo,\r
256 This->DriverBindingHandle,\r
257 Controller,\r
258 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
259 );\r
260 if (EFI_ERROR (Status)) {\r
261 DEBUG ((EFI_D_ERROR, "Open PciIo, Status=%x", Status));\r
262 goto ErrorExit;\r
263 }\r
264\r
265 //\r
266 // We must check EFI_ALREADY_STARTED because many ATAPI devices are removable\r
267 //\r
268 if (SavedStatus != EFI_ALREADY_STARTED) {\r
269 IdeBusDriverPrivateData = AllocatePool (sizeof (IDE_BUS_DRIVER_PRIVATE_DATA));\r
270 if (IdeBusDriverPrivateData == NULL) {\r
271 Status = EFI_OUT_OF_RESOURCES;\r
272 goto ErrorExit;\r
273 }\r
274\r
275 ZeroMem (IdeBusDriverPrivateData, sizeof (IDE_BUS_DRIVER_PRIVATE_DATA));\r
276 Status = gBS->InstallMultipleProtocolInterfaces (\r
277 &Controller,\r
278 &gEfiCallerIdGuid,\r
279 IdeBusDriverPrivateData,\r
280 NULL\r
281 );\r
282 if (EFI_ERROR (Status)) {\r
283 goto ErrorExit;\r
284 }\r
285\r
286 } else {\r
287 Status = gBS->OpenProtocol (\r
288 Controller,\r
289 &gEfiCallerIdGuid,\r
290 (VOID **) &IdeBusDriverPrivateData,\r
291 This->DriverBindingHandle,\r
292 Controller,\r
293 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
294 );\r
295 if (EFI_ERROR (Status)) {\r
296 IdeBusDriverPrivateData = NULL;\r
297 goto ErrorExit;\r
298 }\r
299 }\r
300\r
301 Status = PciIo->Attributes (\r
302 PciIo,\r
303 EfiPciIoAttributeOperationEnable,\r
304 EFI_PCI_DEVICE_ENABLE,\r
305 NULL\r
306 );\r
307 if (EFI_ERROR (Status)) {\r
308 goto ErrorExit;\r
309 }\r
310\r
311 //\r
312 // Read the environment variable that contains the IDEBus Driver's\r
313 // Config options that were set by the Driver Configuration Protocol\r
314 //\r
315 DataSize = sizeof (ConfigurationOptions);\r
316 Status = gRT->GetVariable (\r
317 (CHAR16 *) L"Configuration",\r
318 &gEfiCallerIdGuid,\r
319 &Attributes,\r
320 &DataSize,\r
321 &ConfigurationOptions\r
322 );\r
323 if (EFI_ERROR (Status)) {\r
324 ConfigurationOptions = 0x0f;\r
325 }\r
326\r
327 if (EnumAll) {\r
328 //\r
329 // If IdeInit->EnumAll is TRUE, must enumerate all IDE device anyway\r
330 //\r
331 BeginningIdeChannel = IdePrimary;\r
332 EndIdeChannel = IdeSecondary;\r
333 BeginningIdeDevice = IdeMaster;\r
334 EndIdeDevice = IdeSlave;\r
335 } else if (RemainingDevicePath == NULL) {\r
336 //\r
337 // RemainingDevicePath is NULL, scan IDE bus for each device;\r
338 //\r
339 BeginningIdeChannel = IdePrimary;\r
340 EndIdeChannel = IdeSecondary;\r
341 BeginningIdeDevice = IdeMaster;\r
342 //\r
343 // default, may be redefined by IdeInit\r
344 //\r
345 EndIdeDevice = IdeSlave;\r
346 } else {\r
347 //\r
348 // RemainingDevicePath is not NULL, only scan the specified device.\r
349 //\r
350 Node = (EFI_DEV_PATH *) RemainingDevicePath;\r
351 BeginningIdeChannel = Node->Atapi.PrimarySecondary;\r
352 EndIdeChannel = BeginningIdeChannel;\r
353 BeginningIdeDevice = Node->Atapi.SlaveMaster;\r
354 EndIdeDevice = BeginningIdeDevice;\r
355 }\r
356\r
357 //\r
358 // Obtain IDE IO port registers' base addresses\r
359 //\r
360 Status = GetIdeRegistersBaseAddr (PciIo, IdeRegsBaseAddr);\r
361 if (EFI_ERROR (Status)) {\r
362 goto ErrorExit;\r
363 }\r
364\r
365 //\r
366 // Report status code: begin IdeBus initialization\r
367 //\r
368 REPORT_STATUS_CODE_WITH_DEVICE_PATH (\r
369 EFI_PROGRESS_CODE,\r
370 (EFI_IO_BUS_ATA_ATAPI | EFI_IOB_PC_RESET),\r
371 ParentDevicePath\r
372 );\r
373\r
374 //\r
375 // Strictly follow the enumeration based on IDE_CONTROLLER_INIT protocol\r
376 //\r
377 for (IdeChannel = BeginningIdeChannel; IdeChannel <= EndIdeChannel; IdeChannel++) {\r
378\r
379 IdeInit->NotifyPhase (IdeInit, EfiIdeBeforeChannelEnumeration, IdeChannel);\r
380\r
381 //\r
382 // now obtain channel information fron IdeControllerInit protocol. Step9\r
383 //\r
384 Status = IdeInit->GetChannelInfo (\r
385 IdeInit,\r
386 IdeChannel,\r
387 &ChannelEnabled,\r
388 &MaxDevices\r
389 );\r
390 if (EFI_ERROR (Status)) {\r
391 DEBUG ((EFI_D_ERROR, "[GetChannel, Status=%x]", Status));\r
392 continue;\r
393 }\r
394\r
395 if (!ChannelEnabled) {\r
396 continue;\r
397 }\r
398\r
399 EndIdeDevice = (UINT8) EFI_MIN ((MaxDevices - 1), EndIdeDevice);\r
400\r
401 //\r
402 // Now inform the IDE Controller Init Module. Sept10\r
403 //\r
404 IdeInit->NotifyPhase (IdeInit, EfiIdeBeforeChannelReset, IdeChannel);\r
405\r
406 //\r
407 // No reset channel function implemented. Sept11\r
408 //\r
409 IdeInit->NotifyPhase (IdeInit, EfiIdeAfterChannelReset, IdeChannel);\r
410\r
411 //\r
412 // Step13\r
413 //\r
414 IdeInit->NotifyPhase (\r
415 IdeInit,\r
416 EfiIdeBusBeforeDevicePresenceDetection,\r
417 IdeChannel\r
418 );\r
419 //\r
420 // -- 1st inner loop --- Master/Slave ------------ Step14\r
421 //\r
422 for (IdeDevice = BeginningIdeDevice; IdeDevice <= EndIdeDevice; IdeDevice++) {\r
423 //\r
424 // Check whether the configuration options allow this device\r
425 //\r
426 if (!(ConfigurationOptions & (1 << (IdeChannel * 2 + IdeDevice)))) {\r
427 continue;\r
428 }\r
429 \r
430 //\r
431 // The device has been scanned in another Start(), No need to scan it again\r
432 // for perf optimization.\r
433 //\r
434 if (IdeBusDriverPrivateData->HaveScannedDevice[IdeChannel * 2 + IdeDevice]) {\r
435 continue;\r
436 }\r
437 \r
438 //\r
439 // create child handle for the detected device.\r
440 //\r
441 IdeBlkIoDevice[IdeChannel][IdeDevice] = AllocatePool (sizeof (IDE_BLK_IO_DEV));\r
442 if (IdeBlkIoDevice[IdeChannel][IdeDevice] == NULL) {\r
443 continue;\r
444 }\r
445\r
446 IdeBlkIoDevicePtr = IdeBlkIoDevice[IdeChannel][IdeDevice];\r
447\r
448 ZeroMem (IdeBlkIoDevicePtr, sizeof (IDE_BLK_IO_DEV));\r
449\r
450 IdeBlkIoDevicePtr->Signature = IDE_BLK_IO_DEV_SIGNATURE;\r
451 IdeBlkIoDevicePtr->Channel = IdeChannel;\r
452 IdeBlkIoDevicePtr->Device = IdeDevice;\r
453\r
454 //\r
455 // initialize Block IO interface's Media pointer\r
456 //\r
457 IdeBlkIoDevicePtr->BlkIo.Media = &IdeBlkIoDevicePtr->BlkMedia;\r
458\r
459 //\r
460 // Initialize IDE IO port addresses, including Command Block registers\r
461 // and Control Block registers\r
462 //\r
463 IdeBlkIoDevicePtr->IoPort = AllocatePool (sizeof (IDE_BASE_REGISTERS));\r
464 if (IdeBlkIoDevicePtr->IoPort == NULL) {\r
465 continue;\r
466 }\r
467\r
468 ZeroMem (IdeBlkIoDevicePtr->IoPort, sizeof (IDE_BASE_REGISTERS));\r
469 CommandBlockBaseAddr = IdeRegsBaseAddr[IdeChannel].CommandBlockBaseAddr;\r
470 ControlBlockBaseAddr = IdeRegsBaseAddr[IdeChannel].ControlBlockBaseAddr;\r
471\r
472 IdeBlkIoDevicePtr->IoPort->Data = CommandBlockBaseAddr;\r
473 (*(UINT16 *) &IdeBlkIoDevicePtr->IoPort->Reg1) = (UINT16) (CommandBlockBaseAddr + 0x01);\r
474 IdeBlkIoDevicePtr->IoPort->SectorCount = (UINT16) (CommandBlockBaseAddr + 0x02);\r
475 IdeBlkIoDevicePtr->IoPort->SectorNumber = (UINT16) (CommandBlockBaseAddr + 0x03);\r
476 IdeBlkIoDevicePtr->IoPort->CylinderLsb = (UINT16) (CommandBlockBaseAddr + 0x04);\r
477 IdeBlkIoDevicePtr->IoPort->CylinderMsb = (UINT16) (CommandBlockBaseAddr + 0x05);\r
478 IdeBlkIoDevicePtr->IoPort->Head = (UINT16) (CommandBlockBaseAddr + 0x06);\r
479 (*(UINT16 *) &IdeBlkIoDevicePtr->IoPort->Reg) = (UINT16) (CommandBlockBaseAddr + 0x07);\r
480\r
481 (*(UINT16 *) &IdeBlkIoDevicePtr->IoPort->Alt) = ControlBlockBaseAddr;\r
482 IdeBlkIoDevicePtr->IoPort->DriveAddress = (UINT16) (ControlBlockBaseAddr + 0x01);\r
483\r
484 IdeBlkIoDevicePtr->IoPort->MasterSlave = (UINT16) ((IdeDevice == IdeMaster) ? 1 : 0);\r
485\r
486 IdeBlkIoDevicePtr->PciIo = PciIo;\r
487 IdeBlkIoDevicePtr->IdeBusDriverPrivateData = IdeBusDriverPrivateData;\r
488 IdeBlkIoDevicePtr->IoPort->BusMasterBaseAddr = IdeRegsBaseAddr[IdeChannel].BusMasterBaseAddr;\r
489\r
878ddf1f 490 //\r
491 // Discover device, now!\r
492 //\r
493 PERF_START (0, "DiscoverIdeDevice", "IDE", 0);\r
494 Status = DiscoverIdeDevice (IdeBlkIoDevicePtr);\r
495 PERF_END (0, "DiscoverIdeDevice", "IDE", 0);\r
496\r
497 IdeBusDriverPrivateData->HaveScannedDevice[IdeChannel * 2 + IdeDevice] = TRUE;\r
498 IdeBusDriverPrivateData->DeviceProcessed[IdeChannel * 2 + IdeDevice] = FALSE;\r
499\r
500 if (!EFI_ERROR (Status)) {\r
501 //\r
502 // Set Device Path\r
503 //\r
504 ZeroMem (&NewNode, sizeof (NewNode));\r
505 NewNode.DevPath.Type = MESSAGING_DEVICE_PATH;\r
506 NewNode.DevPath.SubType = MSG_ATAPI_DP;\r
507 SetDevicePathNodeLength (&NewNode.DevPath, sizeof (ATAPI_DEVICE_PATH));\r
508\r
509 NewNode.Atapi.PrimarySecondary = (UINT8) IdeBlkIoDevicePtr->Channel;\r
510 NewNode.Atapi.SlaveMaster = (UINT8) IdeBlkIoDevicePtr->Device;\r
511 NewNode.Atapi.Lun = IdeBlkIoDevicePtr->Lun;\r
512 IdeBlkIoDevicePtr->DevicePath = AppendDevicePathNode (\r
513 ParentDevicePath,\r
514 &NewNode.DevPath\r
515 );\r
516 if (IdeBlkIoDevicePtr->DevicePath == NULL) {\r
517 ReleaseIdeResources (IdeBlkIoDevicePtr);\r
518 continue;\r
519 }\r
520\r
521 //\r
522 // Submit identify data to IDE controller init driver\r
523 //\r
524 CopyMem (&IdentifyData, IdeBlkIoDevicePtr->pIdData, sizeof (IdentifyData));\r
525 // IdentifyData = *IdeBlkIoDevicePtr->pIdData;\r
526 IdeBusDriverPrivateData->DeviceFound[IdeChannel * 2 + IdeDevice] = TRUE;\r
527 IdeInit->SubmitData (IdeInit, IdeChannel, IdeDevice, &IdentifyData);\r
528 } else {\r
529 //\r
530 // Device detection failed\r
531 //\r
532 IdeBusDriverPrivateData->DeviceFound[IdeChannel * 2 + IdeDevice] = FALSE;\r
533 IdeInit->SubmitData (IdeInit, IdeChannel, IdeDevice, NULL);\r
534 ReleaseIdeResources (IdeBlkIoDevicePtr);\r
535 IdeBlkIoDevicePtr = NULL;\r
536 }\r
537 //\r
538 // end of 1st inner loop ---\r
539 //\r
540 }\r
541 //\r
542 // end of 1st outer loop =========\r
543 //\r
544 }\r
545\r
546 //\r
547 // = 2nd outer loop == Primary/Secondary =================\r
548 //\r
549 for (IdeChannel = BeginningIdeChannel; IdeChannel <= EndIdeChannel; IdeChannel++) {\r
550\r
551 //\r
552 // -- 2nd inner loop --- Master/Slave --------\r
553 //\r
554 for (IdeDevice = BeginningIdeDevice; IdeDevice <= EndIdeDevice; IdeDevice++) {\r
555\r
556 if (IdeBusDriverPrivateData->DeviceProcessed[IdeChannel * 2 + IdeDevice]) {\r
557 continue;\r
558 }\r
559\r
560 if (!IdeBusDriverPrivateData->DeviceFound[IdeChannel * 2 + IdeDevice]) {\r
561 continue;\r
562 }\r
563\r
564 Status = IdeInit->CalculateMode (\r
565 IdeInit,\r
566 IdeChannel,\r
567 IdeDevice,\r
568 &SupportedModes\r
569 );\r
570 if (EFI_ERROR (Status)) {\r
571 DEBUG ((EFI_D_ERROR, "[bStStp20S=%x]", Status));\r
572 continue;\r
573 }\r
574\r
575 IdeBlkIoDevicePtr = IdeBlkIoDevice[IdeChannel][IdeDevice];\r
576\r
577 //\r
578 // Set best supported PIO mode on this IDE device\r
579 //\r
580 if (SupportedModes->PioMode.Mode <= ATA_PIO_MODE_2) {\r
581 TransferMode.ModeCategory = ATA_MODE_CATEGORY_DEFAULT_PIO;\r
582 } else {\r
583 TransferMode.ModeCategory = ATA_MODE_CATEGORY_FLOW_PIO;\r
584 }\r
585\r
586 TransferMode.ModeNumber = (UINT8) (SupportedModes->PioMode.Mode);\r
587\r
588 if (SupportedModes->ExtModeCount == 0){\r
589 Status = SetDeviceTransferMode (IdeBlkIoDevicePtr, &TransferMode);\r
590\r
591 if (EFI_ERROR (Status)) {\r
592 IdeBusDriverPrivateData->DeviceFound[IdeChannel * 2 + IdeDevice] = FALSE;\r
593 ReleaseIdeResources (IdeBlkIoDevicePtr);\r
594 IdeBlkIoDevicePtr = NULL;\r
595 continue;\r
596 }\r
597 }\r
598\r
599 //\r
600 // Set supported DMA mode on this IDE device. Note that UDMA & MDMA cann't\r
601 // be set together. Only one DMA mode can be set to a device. If setting\r
602 // DMA mode operation fails, we can continue moving on because we only use\r
603 // PIO mode at boot time. DMA modes are used by certain kind of OS booting\r
604 //\r
605 if (SupportedModes->UdmaMode.Valid) {\r
606\r
607 TransferMode.ModeCategory = ATA_MODE_CATEGORY_UDMA;\r
608 TransferMode.ModeNumber = (UINT8) (SupportedModes->UdmaMode.Mode);\r
609 Status = SetDeviceTransferMode (IdeBlkIoDevicePtr, &TransferMode);\r
610\r
611 if (EFI_ERROR (Status)) {\r
612 IdeBusDriverPrivateData->DeviceFound[IdeChannel * 2 + IdeDevice] = FALSE;\r
613 ReleaseIdeResources (IdeBlkIoDevicePtr);\r
614 IdeBlkIoDevicePtr = NULL;\r
615 continue;\r
616 }\r
617\r
618 EnableInterrupt (IdeBlkIoDevicePtr);\r
619 } else if (SupportedModes->MultiWordDmaMode.Valid) {\r
620\r
621 TransferMode.ModeCategory = ATA_MODE_CATEGORY_MDMA;\r
622 TransferMode.ModeNumber = (UINT8) SupportedModes->MultiWordDmaMode.Mode;\r
623 Status = SetDeviceTransferMode (IdeBlkIoDevicePtr, &TransferMode);\r
624\r
625 if (EFI_ERROR (Status)) {\r
626 IdeBusDriverPrivateData->DeviceFound[IdeChannel * 2 + IdeDevice] = FALSE;\r
627 ReleaseIdeResources (IdeBlkIoDevicePtr);\r
628 IdeBlkIoDevicePtr = NULL;\r
629 continue;\r
630 }\r
631\r
632 EnableInterrupt (IdeBlkIoDevicePtr);\r
633 }\r
634 //\r
635 // Init driver parameters\r
636 //\r
637 DriveParameters.Sector = (UINT8) IdeBlkIoDevicePtr->pIdData->AtaData.sectors_per_track;\r
638 DriveParameters.Heads = (UINT8) (IdeBlkIoDevicePtr->pIdData->AtaData.heads - 1);\r
639 DriveParameters.MultipleSector = (UINT8) IdeBlkIoDevicePtr->pIdData->AtaData.multi_sector_cmd_max_sct_cnt;\r
640 //\r
641 // Set Parameters for the device:\r
642 // 1) Init\r
643 // 2) Establish the block count for READ/WRITE MULTIPLE (EXT) command\r
644 //\r
645 if ((IdeBlkIoDevicePtr->Type == IdeHardDisk) || (IdeBlkIoDevicePtr->Type == Ide48bitAddressingHardDisk)) {\r
646 Status = SetDriveParameters (IdeBlkIoDevicePtr, &DriveParameters);\r
647 }\r
648 \r
649 //\r
650 // Record PIO mode used in private data\r
651 //\r
652 IdeBlkIoDevicePtr->PioMode = SupportedModes->PioMode.Mode;\r
653\r
654 //\r
655 // Set IDE controller Timing Blocks in the PCI Configuration Space\r
656 //\r
657 IdeInit->SetTiming (IdeInit, IdeChannel, IdeDevice, SupportedModes);\r
658\r
659 //\r
660 // Add Component Name for the IDE/ATAPI device that was discovered.\r
661 //\r
662 IdeBlkIoDevicePtr->ControllerNameTable = NULL;\r
663 ADD_NAME (IdeBlkIoDevicePtr);\r
664\r
665 Status = gBS->InstallMultipleProtocolInterfaces (\r
666 &IdeBlkIoDevicePtr->Handle,\r
667 &gEfiDevicePathProtocolGuid,\r
668 IdeBlkIoDevicePtr->DevicePath,\r
669 &gEfiBlockIoProtocolGuid,\r
670 &IdeBlkIoDevicePtr->BlkIo,\r
671 &gEfiDiskInfoProtocolGuid,\r
672 &IdeBlkIoDevicePtr->DiskInfo,\r
673 NULL\r
674 );\r
675\r
676 if (EFI_ERROR (Status)) {\r
677 ReleaseIdeResources (IdeBlkIoDevicePtr);\r
678 }\r
679\r
680 gBS->OpenProtocol (\r
681 Controller,\r
682 &gEfiPciIoProtocolGuid,\r
683 (VOID **) &PciIo,\r
684 This->DriverBindingHandle,\r
685 IdeBlkIoDevicePtr->Handle,\r
686 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER\r
687 );\r
688\r
689 IdeBusDriverPrivateData->DeviceProcessed[IdeChannel * 2 + IdeDevice] = TRUE;\r
690\r
691 //\r
692 // Report status code: device eanbled!\r
693 //\r
694 REPORT_STATUS_CODE_WITH_DEVICE_PATH (\r
695 EFI_PROGRESS_CODE,\r
696 (EFI_IO_BUS_ATA_ATAPI | EFI_P_PC_ENABLE),\r
697 IdeBlkIoDevicePtr->DevicePath\r
698 );\r
699 //\r
700 // end of 2nd inner loop ----\r
701 //\r
702 }\r
703 //\r
704 // end of 2nd outer loop ==========\r
705 //\r
706 }\r
707 \r
708 //\r
709 // All configurations done! Notify IdeController to do post initialization\r
710 // work such as saving IDE controller PCI settings for S3 resume\r
711 //\r
712 IdeInit->NotifyPhase (IdeInit, EfiIdeBusPhaseMaximum, 0);\r
713\r
714 if (SupportedModes != NULL) {\r
715 gBS->FreePool (SupportedModes);\r
716 }\r
717\r
718 PERF_START (0, "Finish IDE detection", "IDE", 1);\r
719 PERF_END (0, "Finish IDE detection", "IDE", 0);\r
720\r
721 return EFI_SUCCESS;\r
722\r
723ErrorExit:\r
724\r
725 //\r
726 // Report error code: controller error\r
727 //\r
728 REPORT_STATUS_CODE_WITH_DEVICE_PATH (\r
729 EFI_ERROR_CODE | EFI_ERROR_MINOR,\r
730 (EFI_IO_BUS_ATA_ATAPI | EFI_IOB_EC_CONTROLLER_ERROR),\r
731 ParentDevicePath\r
732 );\r
733\r
734 gBS->CloseProtocol (\r
735 Controller,\r
736 &gEfiIdeControllerInitProtocolGuid,\r
737 This->DriverBindingHandle,\r
738 Controller\r
739 );\r
740\r
741 gBS->UninstallMultipleProtocolInterfaces (\r
742 Controller,\r
743 &gEfiCallerIdGuid,\r
744 IdeBusDriverPrivateData,\r
745 NULL\r
746 );\r
747\r
748 if (IdeBusDriverPrivateData != NULL) {\r
749 gBS->FreePool (IdeBusDriverPrivateData);\r
750 }\r
751\r
752 if (SupportedModes != NULL) {\r
753 gBS->FreePool (SupportedModes);\r
754 }\r
755\r
756 gBS->CloseProtocol (\r
757 Controller,\r
758 &gEfiPciIoProtocolGuid,\r
759 This->DriverBindingHandle,\r
760 Controller\r
761 );\r
762\r
763 gBS->CloseProtocol (\r
764 Controller,\r
765 &gEfiDevicePathProtocolGuid,\r
766 This->DriverBindingHandle,\r
767 Controller\r
768 );\r
769\r
770 return Status;\r
771\r
772}\r
773\r
774//\r
775// ***********************************************************************************\r
776// IDEBusDriverBindingStop\r
777// ***********************************************************************************\r
778//\r
ed72955c 779/**\r
780 Stop this driver on Controller Handle. \r
781\r
782 @param This Protocol instance pointer.\r
783 @param DeviceHandle Handle of device to stop driver on\r
784 @param NumberOfChildren Not used\r
785 @param ChildHandleBuffer Not used\r
786\r
787 @retval EFI_SUCCESS This driver is removed DeviceHandle\r
788 @retval other This driver was not removed from this device\r
789\r
790**/\r
878ddf1f 791EFI_STATUS\r
792EFIAPI\r
793IDEBusDriverBindingStop (\r
794 IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
795 IN EFI_HANDLE Controller,\r
796 IN UINTN NumberOfChildren,\r
797 IN EFI_HANDLE *ChildHandleBuffer\r
798 )\r
878ddf1f 799// TODO: Controller - add argument and description to function comment\r
800// TODO: EFI_DEVICE_ERROR - add return value to function comment\r
801{\r
802 EFI_STATUS Status;\r
803 EFI_PCI_IO_PROTOCOL *PciIo;\r
804 BOOLEAN AllChildrenStopped;\r
805 UINTN Index;\r
806 IDE_BUS_DRIVER_PRIVATE_DATA *IdeBusDriverPrivateData;\r
807\r
808 IdeBusDriverPrivateData = NULL;\r
809\r
810 if (NumberOfChildren == 0) {\r
811\r
812 Status = gBS->OpenProtocol (\r
813 Controller,\r
814 &gEfiPciIoProtocolGuid,\r
815 (VOID **) &PciIo,\r
816 This->DriverBindingHandle,\r
817 Controller,\r
818 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
819 );\r
820 if (!EFI_ERROR (Status)) {\r
821 PciIo->Attributes (\r
822 PciIo,\r
823 EfiPciIoAttributeOperationDisable,\r
824 EFI_PCI_IO_ATTRIBUTE_IDE_PRIMARY_IO | EFI_PCI_IO_ATTRIBUTE_IDE_SECONDARY_IO | EFI_PCI_DEVICE_ENABLE,\r
825 NULL\r
826 );\r
827 }\r
828\r
829 gBS->OpenProtocol (\r
830 Controller,\r
831 &gEfiCallerIdGuid,\r
832 (VOID **) &IdeBusDriverPrivateData,\r
833 This->DriverBindingHandle,\r
834 Controller,\r
835 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
836 );\r
837\r
838 gBS->UninstallMultipleProtocolInterfaces (\r
839 Controller,\r
840 &gEfiCallerIdGuid,\r
841 IdeBusDriverPrivateData,\r
842 NULL\r
843 );\r
844\r
845 if (IdeBusDriverPrivateData != NULL) {\r
846 gBS->FreePool (IdeBusDriverPrivateData);\r
847 }\r
848 //\r
849 // Close the bus driver\r
850 //\r
851 gBS->CloseProtocol (\r
852 Controller,\r
853 &gEfiIdeControllerInitProtocolGuid,\r
854 This->DriverBindingHandle,\r
855 Controller\r
856 );\r
857 gBS->CloseProtocol (\r
858 Controller,\r
859 &gEfiPciIoProtocolGuid,\r
860 This->DriverBindingHandle,\r
861 Controller\r
862 );\r
863 gBS->CloseProtocol (\r
864 Controller,\r
865 &gEfiDevicePathProtocolGuid,\r
866 This->DriverBindingHandle,\r
867 Controller\r
868 );\r
869\r
870 return EFI_SUCCESS;\r
871 }\r
872\r
873 AllChildrenStopped = TRUE;\r
874\r
875 for (Index = 0; Index < NumberOfChildren; Index++) {\r
876\r
877 Status = DeRegisterIdeDevice (This, Controller, ChildHandleBuffer[Index]);\r
878\r
879 if (EFI_ERROR (Status)) {\r
880 AllChildrenStopped = FALSE;\r
881 }\r
882 }\r
883\r
884 if (!AllChildrenStopped) {\r
885 return EFI_DEVICE_ERROR;\r
886 }\r
887\r
888 return EFI_SUCCESS;\r
889}\r
890\r
891//\r
892// ***********************************************************************************\r
893// DeRegisterIdeDevice\r
894// ***********************************************************************************\r
895//\r
ed72955c 896/**\r
897 Deregister an IDE device and free resources\r
898\r
899 @param This Protocol instance pointer.\r
900 @param Controller Ide device handle\r
901 @param Handle Handle of device to deregister driver on\r
902\r
903 @return EFI_STATUS\r
904\r
905**/\r
878ddf1f 906EFI_STATUS\r
907DeRegisterIdeDevice (\r
908 IN EFI_DRIVER_BINDING_PROTOCOL *This,\r
909 IN EFI_HANDLE Controller,\r
910 IN EFI_HANDLE Handle\r
911 )\r
878ddf1f 912// TODO: EFI_SUCCESS - add return value to function comment\r
913{\r
914 EFI_STATUS Status;\r
915 EFI_BLOCK_IO_PROTOCOL *BlkIo;\r
916 IDE_BLK_IO_DEV *IdeBlkIoDevice;\r
917 EFI_PCI_IO_PROTOCOL *PciIo;\r
918 UINTN Index;\r
919\r
920 Status = gBS->OpenProtocol (\r
921 Handle,\r
922 &gEfiBlockIoProtocolGuid,\r
923 (VOID **) &BlkIo,\r
924 This->DriverBindingHandle,\r
925 Controller,\r
926 EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
927 );\r
928 if (EFI_ERROR (Status)) {\r
929 return Status;\r
930 }\r
931\r
932 IdeBlkIoDevice = IDE_BLOCK_IO_DEV_FROM_THIS (BlkIo);\r
933\r
934 //\r
935 // Report Status code: Device disabled\r
936 //\r
937 REPORT_STATUS_CODE_WITH_DEVICE_PATH (\r
938 EFI_PROGRESS_CODE,\r
939 (EFI_IO_BUS_ATA_ATAPI | EFI_P_PC_DISABLE),\r
940 IdeBlkIoDevice->DevicePath\r
941 );\r
942\r
943 //\r
944 // Close the child handle\r
945 //\r
946 Status = gBS->CloseProtocol (\r
947 Controller,\r
948 &gEfiPciIoProtocolGuid,\r
949 This->DriverBindingHandle,\r
950 Handle\r
951 );\r
952\r
953 Status = gBS->UninstallMultipleProtocolInterfaces (\r
954 Handle,\r
955 &gEfiDevicePathProtocolGuid,\r
956 IdeBlkIoDevice->DevicePath,\r
957 &gEfiBlockIoProtocolGuid,\r
958 &IdeBlkIoDevice->BlkIo,\r
959 &gEfiDiskInfoProtocolGuid,\r
960 &IdeBlkIoDevice->DiskInfo,\r
961 NULL\r
962 );\r
963\r
964 if (EFI_ERROR (Status)) {\r
965 gBS->OpenProtocol (\r
966 Controller,\r
967 &gEfiPciIoProtocolGuid,\r
968 (VOID **) &PciIo,\r
969 This->DriverBindingHandle,\r
970 Handle,\r
971 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER\r
972 );\r
973 return Status;\r
974 }\r
975 \r
976 //\r
977 // Release allocated resources\r
978 //\r
979 Index = IdeBlkIoDevice->Channel * 2 + IdeBlkIoDevice->Device;\r
980 IdeBlkIoDevice->IdeBusDriverPrivateData->HaveScannedDevice[Index] = FALSE;\r
981\r
982 ReleaseIdeResources (IdeBlkIoDevice);\r
983\r
984 return EFI_SUCCESS;\r
985}\r
986\r
987//\r
988// ***********************************************************************************\r
989// IDEBlkIoReset\r
990// ***********************************************************************************\r
991//\r
ed72955c 992/**\r
993 TODO: This - add argument and description to function comment\r
994 TODO: ExtendedVerification - add argument and description to function comment\r
995 TODO: EFI_DEVICE_ERROR - add return value to function comment\r
996\r
997**/\r
878ddf1f 998EFI_STATUS\r
999EFIAPI\r
1000IDEBlkIoReset (\r
1001 IN EFI_BLOCK_IO_PROTOCOL *This,\r
1002 IN BOOLEAN ExtendedVerification\r
1003 )\r
878ddf1f 1004{\r
1005 IDE_BLK_IO_DEV *IdeBlkIoDevice;\r
1006 EFI_STATUS Status;\r
1007\r
1008 IdeBlkIoDevice = IDE_BLOCK_IO_DEV_FROM_THIS (This);\r
1009 //\r
1010 // Requery IDE IO resources in case of the switch of native and legacy modes\r
1011 //\r
1012 ReassignIdeResources (IdeBlkIoDevice);\r
1013\r
1014 //\r
1015 // for ATA device, using ATA reset method\r
1016 //\r
1017 if (IdeBlkIoDevice->Type == IdeHardDisk) {\r
1018 return AtaSoftReset (IdeBlkIoDevice);\r
1019 }\r
1020\r
1021 if (IdeBlkIoDevice->Type == IdeUnknown) {\r
1022 return EFI_DEVICE_ERROR;\r
1023 }\r
1024 \r
1025 //\r
1026 // for ATAPI device, using ATAPI reset method\r
1027 //\r
1028 Status = AtapiSoftReset (IdeBlkIoDevice);\r
1029 if (ExtendedVerification) {\r
1030 Status = AtaSoftReset (IdeBlkIoDevice);\r
1031 }\r
1032\r
1033 return Status;\r
1034}\r
1035\r
ed72955c 1036/**\r
1037 Read data from block io device\r
1038\r
1039 @param This Protocol instance pointer.\r
1040 @param MediaId The media ID of the device\r
1041 @param LBA Starting LBA address to read data\r
1042 @param BufferSize The size of data to be read\r
1043 @param Buffer Caller supplied buffer to save data\r
1044\r
1045 @return read data status\r
1046\r
1047**/\r
878ddf1f 1048EFI_STATUS\r
1049EFIAPI\r
1050IDEBlkIoReadBlocks (\r
1051 IN EFI_BLOCK_IO_PROTOCOL *This,\r
1052 IN UINT32 MediaId,\r
1053 IN EFI_LBA LBA,\r
1054 IN UINTN BufferSize,\r
1055 OUT VOID *Buffer\r
1056 )\r
878ddf1f 1057// TODO: EFI_DEVICE_ERROR - add return value to function comment\r
1058{\r
1059 IDE_BLK_IO_DEV *IdeBlkIoDevice;\r
1060\r
1061 IdeBlkIoDevice = IDE_BLOCK_IO_DEV_FROM_THIS (This);\r
1062\r
1063 //\r
1064 // Requery IDE IO resources in case of the switch of native and legacy modes\r
1065 //\r
1066 ReassignIdeResources (IdeBlkIoDevice);\r
1067\r
1068 //\r
1069 // For ATA compatible device, use ATA read block's mechanism\r
1070 //\r
1071 if (IdeBlkIoDevice->Type == IdeHardDisk ||\r
1072 IdeBlkIoDevice->Type == Ide48bitAddressingHardDisk) {\r
1073 return AtaBlkIoReadBlocks (\r
1074 IdeBlkIoDevice,\r
1075 MediaId,\r
1076 LBA,\r
1077 BufferSize,\r
1078 Buffer\r
1079 );\r
1080 }\r
1081\r
1082 if (IdeBlkIoDevice->Type == IdeUnknown) {\r
1083 return EFI_DEVICE_ERROR;\r
1084 }\r
1085 \r
1086 //\r
1087 // for ATAPI device, using ATAPI read block's mechanism\r
1088 //\r
1089 return AtapiBlkIoReadBlocks (\r
1090 IdeBlkIoDevice,\r
1091 MediaId,\r
1092 LBA,\r
1093 BufferSize,\r
1094 Buffer\r
1095 );\r
1096\r
1097}\r
1098\r
ed72955c 1099/**\r
1100 Write data to block io device\r
1101\r
1102 @param This Protocol instance pointer.\r
1103 @param MediaId The media ID of the device\r
1104 @param LBA Starting LBA address to write data\r
1105 @param BufferSize The size of data to be written\r
1106 @param Buffer Caller supplied buffer to save data\r
1107\r
1108 @return write data status\r
1109\r
1110**/\r
878ddf1f 1111EFI_STATUS\r
1112EFIAPI\r
1113IDEBlkIoWriteBlocks (\r
1114 IN EFI_BLOCK_IO_PROTOCOL *This,\r
1115 IN UINT32 MediaId,\r
1116 IN EFI_LBA LBA,\r
1117 IN UINTN BufferSize,\r
1118 IN VOID *Buffer\r
1119 )\r
878ddf1f 1120// TODO: EFI_DEVICE_ERROR - add return value to function comment\r
1121{\r
1122 IDE_BLK_IO_DEV *IdeBlkIoDevice;\r
1123\r
1124 IdeBlkIoDevice = IDE_BLOCK_IO_DEV_FROM_THIS (This);\r
1125 //\r
1126 // Requery IDE IO resources in case of the switch of native and legacy modes\r
1127 //\r
1128 ReassignIdeResources (IdeBlkIoDevice);\r
1129\r
1130 //\r
1131 // for ATA device, using ATA write block's mechanism\r
1132 //\r
1133 if (IdeBlkIoDevice->Type == IdeHardDisk ||\r
1134 IdeBlkIoDevice->Type == Ide48bitAddressingHardDisk) { \r
1135\r
1136 return AtaBlkIoWriteBlocks (\r
1137 IdeBlkIoDevice,\r
1138 MediaId,\r
1139 LBA,\r
1140 BufferSize,\r
1141 Buffer\r
1142 );\r
1143 }\r
1144\r
1145 if (IdeBlkIoDevice->Type == IdeUnknown) {\r
1146 return EFI_DEVICE_ERROR;\r
1147 }\r
1148 \r
1149 //\r
1150 // for ATAPI device, using ATAPI write block's mechanism\r
1151 //\r
1152 return AtapiBlkIoWriteBlocks (\r
1153 IdeBlkIoDevice,\r
1154 MediaId,\r
1155 LBA,\r
1156 BufferSize,\r
1157 Buffer\r
1158 );\r
1159}\r
1160\r
1161//\r
1162// ***********************************************************************************\r
1163// IDEBlkIoFlushBlocks\r
1164// ***********************************************************************************\r
1165//\r
ed72955c 1166/**\r
1167 TODO: This - add argument and description to function comment\r
1168 TODO: EFI_SUCCESS - add return value to function comment\r
1169**/\r
878ddf1f 1170EFI_STATUS\r
1171EFIAPI\r
1172IDEBlkIoFlushBlocks (\r
1173 IN EFI_BLOCK_IO_PROTOCOL *This\r
1174 )\r
878ddf1f 1175{\r
1176 //\r
1177 // return directly\r
1178 //\r
1179 return EFI_SUCCESS;\r
1180}\r
1181\r
ed72955c 1182/**\r
1183 Return the results of the Inquiry command to a drive in InquiryData.\r
1184 Data format of Inquiry data is defined by the Interface GUID.\r
1185\r
1186 @param This Protocol instance pointer.\r
1187 @param InquiryData Results of Inquiry command to device\r
1188 @param InquiryDataSize Size of InquiryData in bytes.\r
1189\r
1190 @retval EFI_SUCCESS InquiryData valid\r
1191 @retval EFI_NOT_FOUND Device does not support this data class\r
1192 @retval EFI_DEVICE_ERROR Error reading InquiryData from device\r
1193 @retval EFI_BUFFER_TOO_SMALL IntquiryDataSize not big enough\r
1194\r
1195**/\r
878ddf1f 1196EFI_STATUS\r
1197EFIAPI\r
1198IDEDiskInfoInquiry (\r
1199 IN EFI_DISK_INFO_PROTOCOL *This,\r
1200 IN OUT VOID *InquiryData,\r
1201 IN OUT UINT32 *InquiryDataSize\r
1202 )\r
878ddf1f 1203{\r
1204 IDE_BLK_IO_DEV *IdeBlkIoDevice;\r
1205\r
1206 IdeBlkIoDevice = IDE_BLOCK_IO_DEV_FROM_DISK_INFO_THIS (This);\r
1207\r
1208 if (*InquiryDataSize < sizeof (INQUIRY_DATA)) {\r
1209 *InquiryDataSize = sizeof (INQUIRY_DATA);\r
1210 return EFI_BUFFER_TOO_SMALL;\r
1211 }\r
1212\r
1213 if (IdeBlkIoDevice->pInquiryData == NULL) {\r
1214 return EFI_NOT_FOUND;\r
1215 }\r
1216\r
1217 gBS->CopyMem (InquiryData, IdeBlkIoDevice->pInquiryData, sizeof (INQUIRY_DATA));\r
1218 *InquiryDataSize = sizeof (INQUIRY_DATA);\r
1219\r
1220 return EFI_SUCCESS;\r
1221}\r
1222\r
ed72955c 1223/**\r
1224 Return the results of the Identify command to a drive in IdentifyData.\r
1225 Data format of Identify data is defined by the Interface GUID.\r
1226\r
1227 @param This Protocol instance pointer.\r
1228 @param IdentifyData Results of Identify command to device\r
1229 @param IdentifyDataSize Size of IdentifyData in bytes.\r
1230\r
1231 @retval EFI_SUCCESS IdentifyData valid\r
1232 @retval EFI_NOT_FOUND Device does not support this data class\r
1233 @retval EFI_DEVICE_ERROR Error reading IdentifyData from device\r
1234 @retval EFI_BUFFER_TOO_SMALL IdentifyDataSize not big enough\r
1235\r
1236**/\r
878ddf1f 1237EFI_STATUS\r
1238EFIAPI\r
1239IDEDiskInfoIdentify (\r
1240 IN EFI_DISK_INFO_PROTOCOL *This,\r
1241 IN OUT VOID *IdentifyData,\r
1242 IN OUT UINT32 *IdentifyDataSize\r
1243 )\r
878ddf1f 1244{\r
1245 IDE_BLK_IO_DEV *IdeBlkIoDevice;\r
1246\r
1247 IdeBlkIoDevice = IDE_BLOCK_IO_DEV_FROM_DISK_INFO_THIS (This);\r
1248\r
1249 if (*IdentifyDataSize < sizeof (EFI_IDENTIFY_DATA)) {\r
1250 *IdentifyDataSize = sizeof (EFI_IDENTIFY_DATA);\r
1251 return EFI_BUFFER_TOO_SMALL;\r
1252 }\r
1253\r
1254 if (IdeBlkIoDevice->pIdData == NULL) {\r
1255 return EFI_NOT_FOUND;\r
1256 }\r
1257\r
1258 gBS->CopyMem (IdentifyData, IdeBlkIoDevice->pIdData, sizeof (EFI_IDENTIFY_DATA));\r
1259 *IdentifyDataSize = sizeof (EFI_IDENTIFY_DATA);\r
1260\r
1261 return EFI_SUCCESS;\r
1262}\r
1263\r
ed72955c 1264/**\r
1265 Return the results of the Request Sense command to a drive in SenseData.\r
1266 Data format of Sense data is defined by the Interface GUID.\r
1267\r
1268 @param This Protocol instance pointer.\r
1269 @param SenseData Results of Request Sense command to device\r
1270 @param SenseDataSize Size of SenseData in bytes.\r
1271 @param SenseDataNumber Type of SenseData\r
1272\r
1273 @retval EFI_SUCCESS InquiryData valid\r
1274 @retval EFI_NOT_FOUND Device does not support this data class\r
1275 @retval EFI_DEVICE_ERROR Error reading InquiryData from device\r
1276 @retval EFI_BUFFER_TOO_SMALL SenseDataSize not big enough\r
1277\r
1278**/\r
878ddf1f 1279EFI_STATUS\r
1280EFIAPI\r
1281IDEDiskInfoSenseData (\r
1282 IN EFI_DISK_INFO_PROTOCOL *This,\r
1283 IN OUT VOID *SenseData,\r
1284 IN OUT UINT32 *SenseDataSize,\r
1285 OUT UINT8 *SenseDataNumber\r
1286 )\r
878ddf1f 1287{\r
1288 return EFI_NOT_FOUND;\r
1289}\r
1290\r
ed72955c 1291/**\r
1292 Return the results of the Request Sense command to a drive in SenseData.\r
1293 Data format of Sense data is defined by the Interface GUID.\r
1294\r
1295 @param This Protocol instance pointer.\r
1296 @param IdeChannel Primary or Secondary\r
1297 @param IdeDevice Master or Slave\r
1298\r
1299 @retval EFI_SUCCESS IdeChannel and IdeDevice are valid\r
1300 @retval EFI_UNSUPPORTED This is not an IDE device\r
1301\r
1302**/\r
878ddf1f 1303EFI_STATUS\r
1304EFIAPI\r
1305IDEDiskInfoWhichIde (\r
1306 IN EFI_DISK_INFO_PROTOCOL *This,\r
1307 OUT UINT32 *IdeChannel,\r
1308 OUT UINT32 *IdeDevice\r
1309 )\r
878ddf1f 1310{\r
1311 IDE_BLK_IO_DEV *IdeBlkIoDevice;\r
1312\r
1313 IdeBlkIoDevice = IDE_BLOCK_IO_DEV_FROM_DISK_INFO_THIS (This);\r
1314 *IdeChannel = IdeBlkIoDevice->Channel;\r
1315 *IdeDevice = IdeBlkIoDevice->Device;\r
1316\r
1317 return EFI_SUCCESS;\r
1318}\r
EFI Development Kit II mirror for PVE