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