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