]> git.proxmox.com Git - mirror_edk2.git/blame - MdeModulePkg/Bus/Pci/IdeBusPei/AtapiPeim.c
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
NetworkPkg/UefiPxeBcDxe: Fix code style in INF file.
[mirror_edk2.git] / MdeModulePkg / Bus / Pci / IdeBusPei / AtapiPeim.c
CommitLineData
ea060cfa 1/** @file\r
2PEIM to produce gEfiPeiVirtualBlockIoPpiGuid PPI for ATA controllers in the platform.\r
3This PPI canl be consumed by PEIM which produce gEfiPeiDeviceRecoveryModulePpiGuid\r
4for Atapi CD ROM device.\r
5\r
523f48e7 6Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>\r
ea060cfa 7\r
8This program and the accompanying materials\r
9are licensed and made available under the terms and conditions\r
10of the BSD License which accompanies this distribution. The\r
11full text of the license may be found at\r
12http://opensource.org/licenses/bsd-license.php\r
13\r
14THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
15WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
16\r
17**/\r
18\r
19#include "AtapiPeim.h"\r
20\r
21/**\r
22 Initializes the Atapi Block Io PPI. \r
23 \r
24 @param[in] FileHandle Handle of the file being invoked.\r
25 @param[in] PeiServices Describes the list of possible PEI Services.\r
26\r
27 @retval EFI_SUCCESS Operation performed successfully.\r
28 @retval EFI_OUT_OF_RESOURCES Not enough memory to allocate.\r
29\r
30**/\r
31EFI_STATUS\r
32EFIAPI\r
33AtapiPeimEntry (\r
34 IN EFI_PEI_FILE_HANDLE FileHandle,\r
35 IN CONST EFI_PEI_SERVICES **PeiServices\r
36 )\r
37{\r
38 PEI_ATA_CONTROLLER_PPI *AtaControllerPpi;\r
39 EFI_STATUS Status;\r
40 ATAPI_BLK_IO_DEV *AtapiBlkIoDev;\r
41\r
42 Status = PeiServicesRegisterForShadow (FileHandle);\r
43 if (!EFI_ERROR (Status)) {\r
44 return Status;\r
45 }\r
46\r
47 Status = PeiServicesLocatePpi (\r
48 &gPeiAtaControllerPpiGuid,\r
49 0,\r
50 NULL,\r
51 (VOID **) &AtaControllerPpi\r
52 );\r
53 ASSERT_EFI_ERROR (Status);\r
54\r
55 AtapiBlkIoDev = AllocatePages (EFI_SIZE_TO_PAGES (sizeof (*AtapiBlkIoDev)));\r
56 if (AtapiBlkIoDev == NULL) {\r
57 return EFI_OUT_OF_RESOURCES;\r
58 }\r
59\r
60 AtapiBlkIoDev->Signature = ATAPI_BLK_IO_DEV_SIGNATURE;\r
61 AtapiBlkIoDev->AtaControllerPpi = AtaControllerPpi;\r
62\r
63 //\r
64 // atapi device enumeration and build private data\r
65 //\r
66 AtapiEnumerateDevices (AtapiBlkIoDev);\r
67\r
68 AtapiBlkIoDev->AtapiBlkIo.GetNumberOfBlockDevices = AtapiGetNumberOfBlockDevices;\r
69 AtapiBlkIoDev->AtapiBlkIo.GetBlockDeviceMediaInfo = AtapiGetBlockDeviceMediaInfo;\r
70 AtapiBlkIoDev->AtapiBlkIo.ReadBlocks = AtapiReadBlocks;\r
71\r
72 AtapiBlkIoDev->PpiDescriptor.Flags = (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST);\r
73 AtapiBlkIoDev->PpiDescriptor.Guid = &gEfiPeiVirtualBlockIoPpiGuid;\r
74 AtapiBlkIoDev->PpiDescriptor.Ppi = &AtapiBlkIoDev->AtapiBlkIo;\r
75\r
76 DEBUG ((EFI_D_INFO, "Atatpi Device Count is %d\n", AtapiBlkIoDev->DeviceCount));\r
77 if (AtapiBlkIoDev->DeviceCount != 0) {\r
78 Status = PeiServicesInstallPpi (&AtapiBlkIoDev->PpiDescriptor);\r
79 if (EFI_ERROR (Status)) {\r
80 return EFI_OUT_OF_RESOURCES;\r
81 }\r
82 }\r
83\r
84 return EFI_SUCCESS;\r
85}\r
86\r
87/**\r
88 Gets the count of block I/O devices that one specific block driver detects.\r
89\r
90 This function is used for getting the count of block I/O devices that one \r
91 specific block driver detects. To the PEI ATAPI driver, it returns the number\r
92 of all the detected ATAPI devices it detects during the enumeration process. \r
93 To the PEI legacy floppy driver, it returns the number of all the legacy \r
94 devices it finds during its enumeration process. If no device is detected, \r
95 then the function will return zero. \r
96 \r
97 @param[in] PeiServices General-purpose services that are available \r
98 to every PEIM.\r
99 @param[in] This Indicates the EFI_PEI_RECOVERY_BLOCK_IO_PPI \r
100 instance.\r
101 @param[out] NumberBlockDevices The number of block I/O devices discovered.\r
102\r
103 @retval EFI_SUCCESS Operation performed successfully.\r
104\r
105**/\r
106EFI_STATUS\r
107EFIAPI\r
108AtapiGetNumberOfBlockDevices (\r
109 IN EFI_PEI_SERVICES **PeiServices,\r
110 IN EFI_PEI_RECOVERY_BLOCK_IO_PPI *This,\r
111 OUT UINTN *NumberBlockDevices\r
112 )\r
113{\r
114 ATAPI_BLK_IO_DEV *AtapiBlkIoDev;\r
115\r
116 AtapiBlkIoDev = NULL;\r
117\r
118 AtapiBlkIoDev = PEI_RECOVERY_ATAPI_FROM_BLKIO_THIS (This);\r
119\r
120 *NumberBlockDevices = AtapiBlkIoDev->DeviceCount;\r
121\r
122 return EFI_SUCCESS;\r
123}\r
124\r
125/**\r
126 Gets a block device's media information.\r
127\r
128 This function will provide the caller with the specified block device's media \r
129 information. If the media changes, calling this function will update the media \r
130 information accordingly.\r
131\r
132 @param[in] PeiServices General-purpose services that are available to every\r
133 PEIM\r
134 @param[in] This Indicates the EFI_PEI_RECOVERY_BLOCK_IO_PPI instance.\r
135 @param[in] DeviceIndex Specifies the block device to which the function wants \r
136 to talk. Because the driver that implements Block I/O \r
137 PPIs will manage multiple block devices, the PPIs that \r
138 want to talk to a single device must specify the \r
139 device index that was assigned during the enumeration\r
140 process. This index is a number from one to \r
141 NumberBlockDevices.\r
142 @param[out] MediaInfo The media information of the specified block media. \r
143 The caller is responsible for the ownership of this \r
144 data structure.\r
145 \r
146 @retval EFI_SUCCESS Media information about the specified block device \r
147 was obtained successfully.\r
148 @retval EFI_DEVICE_ERROR Cannot get the media information due to a hardware \r
149 error.\r
150 @retval Others Other failure occurs.\r
151\r
152**/\r
153EFI_STATUS\r
154EFIAPI\r
155AtapiGetBlockDeviceMediaInfo (\r
156 IN EFI_PEI_SERVICES **PeiServices,\r
157 IN EFI_PEI_RECOVERY_BLOCK_IO_PPI *This,\r
158 IN UINTN DeviceIndex,\r
159 OUT EFI_PEI_BLOCK_IO_MEDIA *MediaInfo\r
160 )\r
161{\r
162 UINTN DeviceCount;\r
163 ATAPI_BLK_IO_DEV *AtapiBlkIoDev;\r
164 EFI_STATUS Status;\r
165 UINTN Index;\r
166\r
167 AtapiBlkIoDev = NULL;\r
168\r
169 if (This == NULL || MediaInfo == NULL) {\r
170 return EFI_INVALID_PARAMETER;\r
171 }\r
172\r
173 AtapiBlkIoDev = PEI_RECOVERY_ATAPI_FROM_BLKIO_THIS (This);\r
174\r
175 DeviceCount = AtapiBlkIoDev->DeviceCount;\r
176\r
177 //\r
178 // DeviceIndex is a value from 1 to NumberBlockDevices.\r
179 //\r
180 if ((DeviceIndex < 1) || (DeviceIndex > DeviceCount) || (DeviceIndex > MAX_IDE_DEVICES)) {\r
181 return EFI_INVALID_PARAMETER;\r
182 }\r
183\r
184 Index = DeviceIndex - 1;\r
185\r
186 //\r
187 // probe media and retrieve latest media information\r
188 //\r
189 DEBUG ((EFI_D_INFO, "Atatpi GetInfo DevicePosition is %d\n", AtapiBlkIoDev->DeviceInfo[Index].DevicePosition)); \r
190 DEBUG ((EFI_D_INFO, "Atatpi GetInfo DeviceType is %d\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.DeviceType));\r
191 DEBUG ((EFI_D_INFO, "Atatpi GetInfo MediaPresent is %d\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.MediaPresent));\r
192 DEBUG ((EFI_D_INFO, "Atatpi GetInfo BlockSize is 0x%x\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.BlockSize));\r
193 DEBUG ((EFI_D_INFO, "Atatpi GetInfo LastBlock is 0x%x\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.LastBlock));\r
194\r
195 Status = DetectMedia (\r
196 AtapiBlkIoDev,\r
197 AtapiBlkIoDev->DeviceInfo[Index].DevicePosition,\r
198 &AtapiBlkIoDev->DeviceInfo[Index].MediaInfo\r
199 );\r
200 if (Status != EFI_SUCCESS) {\r
201 return EFI_DEVICE_ERROR;\r
202 }\r
203\r
204 DEBUG ((EFI_D_INFO, "Atatpi GetInfo DevicePosition is %d\n", AtapiBlkIoDev->DeviceInfo[Index].DevicePosition));\r
205 DEBUG ((EFI_D_INFO, "Atatpi GetInfo DeviceType is %d\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.DeviceType));\r
206 DEBUG ((EFI_D_INFO, "Atatpi GetInfo MediaPresent is %d\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.MediaPresent));\r
207 DEBUG ((EFI_D_INFO, "Atatpi GetInfo BlockSize is 0x%x\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.BlockSize));\r
208 DEBUG ((EFI_D_INFO, "Atatpi GetInfo LastBlock is 0x%x\n", AtapiBlkIoDev->DeviceInfo[Index].MediaInfo.LastBlock));\r
209 \r
210 //\r
211 // Get media info from AtapiBlkIoDev\r
212 //\r
213 CopyMem (MediaInfo, &AtapiBlkIoDev->DeviceInfo[Index].MediaInfo, sizeof(EFI_PEI_BLOCK_IO_MEDIA));\r
214\r
215 return EFI_SUCCESS;\r
216}\r
217\r
218/**\r
219 Reads the requested number of blocks from the specified block device.\r
220\r
221 The function reads the requested number of blocks from the device. All the \r
222 blocks are read, or an error is returned. If there is no media in the device,\r
223 the function returns EFI_NO_MEDIA.\r
224\r
225 @param[in] PeiServices General-purpose services that are available to \r
226 every PEIM.\r
227 @param[in] This Indicates the EFI_PEI_RECOVERY_BLOCK_IO_PPI instance.\r
228 @param[in] DeviceIndex Specifies the block device to which the function wants \r
229 to talk. Because the driver that implements Block I/O \r
230 PPIs will manage multiple block devices, the PPIs that \r
231 want to talk to a single device must specify the device \r
232 index that was assigned during the enumeration process. \r
233 This index is a number from one to NumberBlockDevices.\r
234 @param[in] StartLBA The starting logical block address (LBA) to read from\r
235 on the device\r
236 @param[in] BufferSize The size of the Buffer in bytes. This number must be\r
237 a multiple of the intrinsic block size of the device.\r
238 @param[out] Buffer A pointer to the destination buffer for the data.\r
239 The caller is responsible for the ownership of the \r
240 buffer.\r
241 \r
242 @retval EFI_SUCCESS The data was read correctly from the device.\r
243 @retval EFI_DEVICE_ERROR The device reported an error while attempting \r
244 to perform the read operation.\r
245 @retval EFI_INVALID_PARAMETER The read request contains LBAs that are not \r
246 valid, or the buffer is not properly aligned.\r
247 @retval EFI_NO_MEDIA There is no media in the device.\r
248 @retval EFI_BAD_BUFFER_SIZE The BufferSize parameter is not a multiple of\r
249 the intrinsic block size of the device.\r
250\r
251**/\r
252EFI_STATUS\r
253EFIAPI\r
254AtapiReadBlocks (\r
255 IN EFI_PEI_SERVICES **PeiServices,\r
256 IN EFI_PEI_RECOVERY_BLOCK_IO_PPI *This,\r
257 IN UINTN DeviceIndex,\r
258 IN EFI_PEI_LBA StartLBA,\r
259 IN UINTN BufferSize,\r
260 OUT VOID *Buffer\r
261 )\r
262{\r
263\r
264 EFI_PEI_BLOCK_IO_MEDIA MediaInfo;\r
265 EFI_STATUS Status;\r
266 UINTN NumberOfBlocks;\r
267 UINTN BlockSize;\r
268 ATAPI_BLK_IO_DEV *AtapiBlkIoDev;\r
269\r
270 AtapiBlkIoDev = NULL;\r
271\r
272 if (This == NULL) {\r
273 return EFI_INVALID_PARAMETER;\r
274 }\r
275\r
276 AtapiBlkIoDev = PEI_RECOVERY_ATAPI_FROM_BLKIO_THIS (This);\r
277\r
278 if (Buffer == NULL) {\r
279 return EFI_INVALID_PARAMETER;\r
280 }\r
281\r
282 if (BufferSize == 0) {\r
283 return EFI_SUCCESS;\r
284 }\r
285\r
286 Status = AtapiGetBlockDeviceMediaInfo (\r
287 PeiServices,\r
288 This,\r
289 DeviceIndex,\r
290 &MediaInfo\r
291 );\r
292 if (Status != EFI_SUCCESS) {\r
293 return EFI_DEVICE_ERROR;\r
294 }\r
295\r
296 if (!MediaInfo.MediaPresent) {\r
297 return EFI_NO_MEDIA;\r
298 }\r
299\r
300 BlockSize = MediaInfo.BlockSize;\r
301\r
302 if (BufferSize % BlockSize != 0) {\r
303 return EFI_BAD_BUFFER_SIZE;\r
304 }\r
305\r
306 NumberOfBlocks = BufferSize / BlockSize;\r
307\r
308 if ((StartLBA + NumberOfBlocks - 1) > AtapiBlkIoDev->DeviceInfo[DeviceIndex - 1].MediaInfo.LastBlock) {\r
309 return EFI_INVALID_PARAMETER;\r
310 }\r
311\r
312 Status = ReadSectors (\r
313 AtapiBlkIoDev,\r
314 AtapiBlkIoDev->DeviceInfo[DeviceIndex - 1].DevicePosition,\r
315 Buffer,\r
316 StartLBA,\r
317 NumberOfBlocks,\r
318 BlockSize\r
319 );\r
320 if (EFI_ERROR (Status)) {\r
321 return EFI_DEVICE_ERROR;\r
322 }\r
323\r
324 return EFI_SUCCESS;\r
325}\r
326\r
327/**\r
328 Enumerate Atapi devices.\r
329\r
330 This function is used to enumerate Atatpi device in Ide channel.\r
331\r
332 @param[in] AtapiBlkIoDev A pointer to atapi block IO device\r
333\r
334**/\r
335VOID\r
336AtapiEnumerateDevices (\r
337 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev\r
338 )\r
339{\r
340 UINT8 Index1;\r
341 UINT8 Index2;\r
342 UINTN DevicePosition;\r
343 EFI_PEI_BLOCK_IO_MEDIA MediaInfo;\r
344 EFI_STATUS Status;\r
345 UINTN DeviceCount;\r
346 UINT16 CommandBlockBaseAddr;\r
347 UINT16 ControlBlockBaseAddr;\r
348 UINT32 IdeEnabledNumber;\r
349 IDE_REGS_BASE_ADDR IdeRegsBaseAddr[MAX_IDE_CHANNELS];\r
350\r
351 DeviceCount = 0;\r
352 DevicePosition = 0;\r
353\r
354 //\r
355 // Scan IDE bus for ATAPI devices\r
356 //\r
357\r
358 //\r
359 // Enable Sata and IDE controller.\r
360 //\r
361 AtapiBlkIoDev->AtaControllerPpi->EnableAtaChannel (\r
362 (EFI_PEI_SERVICES **) GetPeiServicesTablePointer(),\r
363 AtapiBlkIoDev->AtaControllerPpi,\r
364 PEI_ICH_IDE_PRIMARY | PEI_ICH_IDE_SECONDARY\r
365 );\r
366\r
367 //\r
368 // Allow SATA Devices to spin-up. This is needed if \r
369 // SEC and PEI phase is too short, for example Release Build.\r
370 //\r
371 DEBUG ((EFI_D_INFO, "Delay for %d seconds for SATA devices to spin-up\n", PcdGet16 (PcdSataSpinUpDelayInSecForRecoveryPath)));\r
372 MicroSecondDelay (PcdGet16 (PcdSataSpinUpDelayInSecForRecoveryPath) * 1000 * 1000); //\r
373\r
374 //\r
375 // Get four channels (primary or secondary Pata, Sata Channel) Command and Control Regs Base address.\r
376 //\r
377 IdeEnabledNumber = AtapiBlkIoDev->AtaControllerPpi->GetIdeRegsBaseAddr (\r
378 (EFI_PEI_SERVICES **) GetPeiServicesTablePointer(),\r
379 AtapiBlkIoDev->AtaControllerPpi,\r
380 IdeRegsBaseAddr\r
381 );\r
382\r
383 //\r
384 // Using Command and Control Regs Base Address to fill other registers.\r
385 //\r
386 for (Index1 = 0; Index1 < IdeEnabledNumber; Index1 ++) { \r
387 CommandBlockBaseAddr = IdeRegsBaseAddr[Index1].CommandBlockBaseAddr;\r
388 AtapiBlkIoDev->IdeIoPortReg[Index1].Data = CommandBlockBaseAddr;\r
389 AtapiBlkIoDev->IdeIoPortReg[Index1].Reg1.Feature = (UINT16) (CommandBlockBaseAddr + 0x1);\r
390 AtapiBlkIoDev->IdeIoPortReg[Index1].SectorCount = (UINT16) (CommandBlockBaseAddr + 0x2);\r
391 AtapiBlkIoDev->IdeIoPortReg[Index1].SectorNumber = (UINT16) (CommandBlockBaseAddr + 0x3);\r
392 AtapiBlkIoDev->IdeIoPortReg[Index1].CylinderLsb = (UINT16) (CommandBlockBaseAddr + 0x4);\r
393 AtapiBlkIoDev->IdeIoPortReg[Index1].CylinderMsb = (UINT16) (CommandBlockBaseAddr + 0x5);\r
394 AtapiBlkIoDev->IdeIoPortReg[Index1].Head = (UINT16) (CommandBlockBaseAddr + 0x6);\r
395 AtapiBlkIoDev->IdeIoPortReg[Index1].Reg.Command = (UINT16) (CommandBlockBaseAddr + 0x7);\r
396\r
397 ControlBlockBaseAddr = IdeRegsBaseAddr[Index1].ControlBlockBaseAddr;\r
398 AtapiBlkIoDev->IdeIoPortReg[Index1].Alt.DeviceControl = ControlBlockBaseAddr;\r
399 AtapiBlkIoDev->IdeIoPortReg[Index1].DriveAddress = (UINT16) (ControlBlockBaseAddr + 0x1);\r
400 \r
401 //\r
402 // Scan IDE bus for ATAPI devices IDE or Sata device\r
403 //\r
404 for (Index2 = IdeMaster; Index2 < IdeMaxDevice; Index2++) {\r
405 //\r
406 // Pata & Sata, Primary & Secondary channel, Master & Slave device\r
407 //\r
408 DevicePosition = (UINTN) (Index1 * 2 + Index2);\r
409\r
410 if (DiscoverAtapiDevice (AtapiBlkIoDev, DevicePosition, &MediaInfo)) {\r
411 //\r
412 // ATAPI Device at DevicePosition is found.\r
413 //\r
414 AtapiBlkIoDev->DeviceInfo[DeviceCount].DevicePosition = DevicePosition;\r
415 //\r
416 // Retrieve Media Info\r
417 //\r
418 Status = DetectMedia (AtapiBlkIoDev, DevicePosition, &MediaInfo);\r
419 CopyMem (&(AtapiBlkIoDev->DeviceInfo[DeviceCount].MediaInfo), &MediaInfo, sizeof (MediaInfo));\r
420 \r
421 DEBUG ((EFI_D_INFO, "Atatpi Device Position is %d\n", DevicePosition));\r
422 DEBUG ((EFI_D_INFO, "Atatpi DeviceType is %d\n", MediaInfo.DeviceType));\r
423 DEBUG ((EFI_D_INFO, "Atatpi MediaPresent is %d\n", MediaInfo.MediaPresent));\r
424 DEBUG ((EFI_D_INFO, "Atatpi BlockSize is 0x%x\n", MediaInfo.BlockSize));\r
425\r
426 if (EFI_ERROR (Status)) {\r
427 AtapiBlkIoDev->DeviceInfo[DeviceCount].MediaInfo.MediaPresent = FALSE;\r
428 AtapiBlkIoDev->DeviceInfo[DeviceCount].MediaInfo.LastBlock = 0;\r
429 }\r
430 DeviceCount += 1;\r
431 }\r
432 }\r
433 }\r
434\r
435 AtapiBlkIoDev->DeviceCount = DeviceCount;\r
436}\r
437\r
438/**\r
439 Detect Atapi devices.\r
440 \r
441 @param[in] AtapiBlkIoDev A pointer to atapi block IO device.\r
442 @param[in] DevicePosition An integer to signify device position.\r
443 @param[out] MediaInfo The media information of the specified block media.\r
444\r
445 @retval TRUE Atapi device exists in specified position.\r
446 @retval FALSE Atapi device does not exist in specified position.\r
447\r
448**/\r
449BOOLEAN\r
450DiscoverAtapiDevice (\r
451 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,\r
452 IN UINTN DevicePosition,\r
453 OUT EFI_PEI_BLOCK_IO_MEDIA *MediaInfo\r
454 )\r
455{\r
456 EFI_STATUS Status;\r
457\r
458 if (!DetectIDEController (AtapiBlkIoDev, DevicePosition)) {\r
459 return FALSE;\r
460 }\r
461 //\r
462 // test if it is an ATAPI device (only supported device)\r
463 //\r
464 if (ATAPIIdentify (AtapiBlkIoDev, DevicePosition) == EFI_SUCCESS) {\r
465\r
466 Status = Inquiry (AtapiBlkIoDev, DevicePosition, MediaInfo);\r
467 if (!EFI_ERROR (Status)) {\r
468 return TRUE;\r
469 }\r
470 }\r
471\r
472 return FALSE;\r
473}\r
474\r
475/**\r
476 Check power mode of Atapi devices.\r
477 \r
478 @param[in] AtapiBlkIoDev A pointer to atapi block IO device.\r
479 @param[in] DevicePosition An integer to signify device position.\r
480 @param[in] AtaCommand The Ata Command passed in.\r
481\r
482 @retval EFI_SUCCESS The Atapi device support power mode.\r
483 @retval EFI_NOT_FOUND The Atapi device not found.\r
484 @retval EFI_TIMEOUT Atapi command transaction is time out.\r
485 @retval EFI_ABORTED Atapi command abort.\r
486\r
487**/\r
488EFI_STATUS\r
489CheckPowerMode (\r
490 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,\r
491 IN UINTN DevicePosition,\r
492 IN UINT8 AtaCommand\r
493 )\r
494{\r
495 UINT8 Channel;\r
496 UINT8 Device;\r
497 UINT16 StatusRegister;\r
498 UINT16 HeadRegister;\r
499 UINT16 CommandRegister;\r
500 UINT16 ErrorRegister;\r
501 UINT16 SectorCountRegister;\r
502 EFI_STATUS Status;\r
503 UINT8 StatusValue;\r
504 UINT8 ErrorValue;\r
505 UINT8 SectorCountValue;\r
506\r
507 Channel = (UINT8) (DevicePosition / 2);\r
508 Device = (UINT8) (DevicePosition % 2);\r
509\r
510 ASSERT (Channel < MAX_IDE_CHANNELS);\r
511\r
512 StatusRegister = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg.Status;\r
513 HeadRegister = AtapiBlkIoDev->IdeIoPortReg[Channel].Head;\r
514 CommandRegister = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg.Command;\r
515 ErrorRegister = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg1.Error;\r
516 SectorCountRegister = AtapiBlkIoDev->IdeIoPortReg[Channel].SectorCount;\r
517\r
518 //\r
519 // select device\r
520 //\r
521 IoWrite8 (HeadRegister, (UINT8) ((Device << 4) | 0xe0));\r
522\r
523 //\r
524 // refresh the SectorCount register\r
525 //\r
526 SectorCountValue = 0x55;\r
527 IoWrite8 (SectorCountRegister, SectorCountValue);\r
528\r
529 //\r
530 // select device\r
531 //\r
532 IoWrite8 (HeadRegister, (UINT8) ((Device << 4) | 0xe0));\r
533\r
534 Status = DRDYReady (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), 100);\r
535\r
536 //\r
537 // select device\r
538 //\r
539 IoWrite8 (HeadRegister, (UINT8) ((Device << 4) | 0xe0));\r
540 //\r
541 // send 'check power' commandd via Command Register\r
542 //\r
543 IoWrite8 (CommandRegister, AtaCommand);\r
544\r
545 Status = WaitForBSYClear (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), 3000);\r
546 if (EFI_ERROR (Status)) {\r
547 return EFI_TIMEOUT;\r
548 }\r
549\r
550 StatusValue = IoRead8 (StatusRegister);\r
551\r
552 //\r
553 // command returned status is DRDY, indicating device supports the command,\r
554 // so device is present.\r
555 //\r
556 if ((StatusValue & ATA_STSREG_DRDY) == ATA_STSREG_DRDY) {\r
557 return EFI_SUCCESS;\r
558 }\r
559\r
560 SectorCountValue = IoRead8 (SectorCountRegister);\r
561\r
562 //\r
563 // command returned status is ERR & ABRT_ERR, indicating device does not support\r
564 // the command, so device is present.\r
565 //\r
566 if ((StatusValue & ATA_STSREG_ERR) == ATA_STSREG_ERR) {\r
567 ErrorValue = IoRead8 (ErrorRegister);\r
568 if ((ErrorValue & ATA_ERRREG_ABRT) == ATA_ERRREG_ABRT) {\r
569 return EFI_ABORTED;\r
570 } else {\r
571 //\r
572 // According to spec, no other error code is valid\r
573 //\r
574 return EFI_NOT_FOUND;\r
575 }\r
576 }\r
577\r
578 if ((SectorCountValue == 0x00) || (SectorCountValue == 0x80) || (SectorCountValue == 0xff)) {\r
579 //\r
580 // Write SectorCount 0x55 but return valid state value. Maybe no device\r
581 // exists or some slow kind of ATAPI device exists.\r
582 //\r
583 IoWrite8 (HeadRegister, (UINT8) ((Device << 4) | 0xe0));\r
584\r
585 //\r
586 // write 0x55 and 0xaa to SectorCounter register,\r
587 // if the data could be written into the register,\r
588 // indicating the device is present, otherwise the device is not present.\r
589 //\r
590 SectorCountValue = 0x55;\r
591 IoWrite8 (SectorCountRegister, SectorCountValue);\r
592 MicroSecondDelay (10000);\r
593\r
594 SectorCountValue = IoRead8 (SectorCountRegister);\r
595 if (SectorCountValue != 0x55) {\r
596 return EFI_NOT_FOUND;\r
597 }\r
598 //\r
599 // Send a "ATAPI TEST UNIT READY" command ... slow but accurate\r
600 //\r
601 Status = TestUnitReady (AtapiBlkIoDev, DevicePosition);\r
602 return Status;\r
603 }\r
604\r
605 return EFI_NOT_FOUND;\r
606}\r
607\r
608/**\r
609 Detect if an IDE controller exists in specified position.\r
610 \r
611 @param[in] AtapiBlkIoDev A pointer to atapi block IO device.\r
612 @param[in] DevicePosition An integer to signify device position.\r
613\r
614 @retval TRUE The Atapi device exists.\r
615 @retval FALSE The Atapi device does not present.\r
616\r
617**/\r
618BOOLEAN\r
619DetectIDEController (\r
620 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,\r
621 IN UINTN DevicePosition\r
622 )\r
623{\r
624 UINT8 Channel;\r
625 EFI_STATUS Status;\r
626 UINT8 AtaCommand;\r
627\r
628 Channel = (UINT8) (DevicePosition / 2);\r
629\r
630 ASSERT (Channel < MAX_IDE_CHANNELS);\r
631 //\r
632 // Wait 31 seconds for BSY clear\r
633 //\r
634 Status = WaitForBSYClear (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), 31000);\r
635 if (EFI_ERROR (Status)) {\r
636 return FALSE;\r
637 }\r
638 //\r
639 // Send 'check power' command for IDE device\r
640 //\r
641 AtaCommand = 0xE5;\r
642 Status = CheckPowerMode (AtapiBlkIoDev, DevicePosition, AtaCommand);\r
643 if ((Status == EFI_ABORTED) || (Status == EFI_SUCCESS)) {\r
644 return TRUE;\r
645 }\r
646\r
647 return FALSE;\r
648}\r
649\r
650/**\r
651 Wait specified time interval to poll for BSY bit clear in the Status Register.\r
652 \r
653 @param[in] AtapiBlkIoDev A pointer to atapi block IO device.\r
654 @param[in] IdeIoRegisters A pointer to IDE IO registers.\r
655 @param[in] TimeoutInMilliSeconds Time specified in milliseconds.\r
656\r
657 @retval EFI_SUCCESS BSY bit is cleared in the specified time interval.\r
658 @retval EFI_TIMEOUT BSY bit is not cleared in the specified time interval.\r
659\r
660**/\r
661EFI_STATUS\r
662WaitForBSYClear (\r
663 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,\r
664 IN IDE_BASE_REGISTERS *IdeIoRegisters,\r
665 IN UINTN TimeoutInMilliSeconds\r
666 )\r
667{\r
668 UINTN Delay;\r
669 UINT16 StatusRegister;\r
670 UINT8 StatusValue;\r
671\r
672 StatusValue = 0;\r
673\r
674 StatusRegister = IdeIoRegisters->Reg.Status;\r
675\r
676 Delay = ((TimeoutInMilliSeconds * STALL_1_MILLI_SECOND) / 250) + 1;\r
677 do {\r
678 StatusValue = IoRead8 (StatusRegister);\r
679 if ((StatusValue & ATA_STSREG_BSY) == 0x00) {\r
680 break;\r
681 }\r
682 MicroSecondDelay (250);\r
683\r
684 Delay--;\r
685\r
686 } while (Delay != 0);\r
687\r
688 if (Delay == 0) {\r
689 return EFI_TIMEOUT;\r
690 }\r
691\r
692 return EFI_SUCCESS;\r
693}\r
694\r
695/**\r
696 Wait specified time interval to poll for DRDY bit set in the Status register.\r
697 \r
698 @param[in] AtapiBlkIoDev A pointer to atapi block IO device.\r
699 @param[in] IdeIoRegisters A pointer to IDE IO registers.\r
700 @param[in] TimeoutInMilliSeconds Time specified in milliseconds.\r
701\r
702 @retval EFI_SUCCESS DRDY bit is set in the specified time interval.\r
703 @retval EFI_TIMEOUT DRDY bit is not set in the specified time interval.\r
704\r
705**/\r
706EFI_STATUS\r
707DRDYReady (\r
708 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,\r
709 IN IDE_BASE_REGISTERS *IdeIoRegisters,\r
710 IN UINTN TimeoutInMilliSeconds\r
711 )\r
712{\r
713 UINTN Delay;\r
714 UINT16 StatusRegister;\r
715 UINT8 StatusValue;\r
716 UINT8 ErrValue;\r
717\r
718 StatusValue = 0;\r
719\r
720 StatusRegister = IdeIoRegisters->Reg.Status;\r
721\r
722 Delay = ((TimeoutInMilliSeconds * STALL_1_MILLI_SECOND) / 250) + 1;\r
723 do {\r
724 StatusValue = IoRead8 (StatusRegister);\r
725 //\r
726 // BSY == 0 , DRDY == 1\r
727 //\r
728 if ((StatusValue & (ATA_STSREG_DRDY | ATA_STSREG_BSY)) == ATA_STSREG_DRDY) {\r
729 break;\r
730 }\r
731\r
732 if ((StatusValue & (ATA_STSREG_ERR | ATA_STSREG_BSY)) == ATA_STSREG_ERR) {\r
733 ErrValue = IoRead8 (IdeIoRegisters->Reg1.Error);\r
734 if ((ErrValue & ATA_ERRREG_ABRT) == ATA_ERRREG_ABRT) {\r
735 return EFI_ABORTED;\r
736 }\r
737 }\r
738 \r
739 MicroSecondDelay (250);\r
740\r
741 Delay--;\r
742\r
743 } while (Delay != 0);\r
744\r
745 if (Delay == 0) {\r
746 return EFI_TIMEOUT;\r
747 }\r
748\r
749 return EFI_SUCCESS;\r
750}\r
751\r
752/**\r
753 Wait specified time interval to poll for DRQ bit clear in the Status Register.\r
754 \r
755 @param[in] AtapiBlkIoDev A pointer to atapi block IO device.\r
756 @param[in] IdeIoRegisters A pointer to IDE IO registers.\r
757 @param[in] TimeoutInMilliSeconds Time specified in milliseconds.\r
758\r
759 @retval EFI_SUCCESS DRQ bit is cleared in the specified time interval.\r
760 @retval EFI_TIMEOUT DRQ bit is not cleared in the specified time interval.\r
761\r
762**/\r
763EFI_STATUS\r
764DRQClear (\r
765 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,\r
766 IN IDE_BASE_REGISTERS *IdeIoRegisters,\r
767 IN UINTN TimeoutInMilliSeconds\r
768 )\r
769{\r
770 UINTN Delay;\r
771 UINT16 StatusRegister;\r
772 UINT8 StatusValue;\r
773 UINT8 ErrValue;\r
774\r
775 StatusValue = 0;\r
776\r
777 StatusRegister = IdeIoRegisters->Reg.Status;\r
778\r
779 Delay = ((TimeoutInMilliSeconds * STALL_1_MILLI_SECOND) / 250) + 1;\r
780 do {\r
781\r
782 StatusValue = IoRead8 (StatusRegister);\r
783\r
784 //\r
785 // wait for BSY == 0 and DRQ == 0\r
786 //\r
787 if ((StatusValue & (ATA_STSREG_DRQ | ATA_STSREG_BSY)) == 0) {\r
788 break;\r
789 }\r
790\r
791 if ((StatusValue & (ATA_STSREG_BSY | ATA_STSREG_ERR)) == ATA_STSREG_ERR) {\r
792 ErrValue = IoRead8 (IdeIoRegisters->Reg1.Error);\r
793 if ((ErrValue & ATA_ERRREG_ABRT) == ATA_ERRREG_ABRT) {\r
794 return EFI_ABORTED;\r
795 }\r
796 }\r
797 \r
798 MicroSecondDelay (250);\r
799\r
800 Delay--;\r
801 } while (Delay != 0);\r
802\r
803 if (Delay == 0) {\r
804 return EFI_TIMEOUT;\r
805 }\r
806\r
807 return EFI_SUCCESS;\r
808}\r
809\r
810/**\r
811 Wait specified time interval to poll for DRQ bit clear in the Alternate Status Register.\r
812 \r
813 @param[in] AtapiBlkIoDev A pointer to atapi block IO device.\r
814 @param[in] IdeIoRegisters A pointer to IDE IO registers.\r
815 @param[in] TimeoutInMilliSeconds Time specified in milliseconds.\r
816\r
817 @retval EFI_SUCCESS DRQ bit is cleared in the specified time interval.\r
818 @retval EFI_TIMEOUT DRQ bit is not cleared in the specified time interval.\r
819\r
820**/\r
821EFI_STATUS\r
822DRQClear2 (\r
823 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,\r
824 IN IDE_BASE_REGISTERS *IdeIoRegisters,\r
825 IN UINTN TimeoutInMilliSeconds\r
826 )\r
827{\r
828 UINTN Delay;\r
829 UINT16 AltStatusRegister;\r
830 UINT8 AltStatusValue;\r
831 UINT8 ErrValue;\r
832\r
833 AltStatusValue = 0;\r
834\r
835 AltStatusRegister = IdeIoRegisters->Alt.AltStatus;\r
836\r
837 Delay = ((TimeoutInMilliSeconds * STALL_1_MILLI_SECOND) / 250) + 1;\r
838 do {\r
839\r
840 AltStatusValue = IoRead8 (AltStatusRegister);\r
841\r
842 //\r
843 // wait for BSY == 0 and DRQ == 0\r
844 //\r
845 if ((AltStatusValue & (ATA_STSREG_DRQ | ATA_STSREG_BSY)) == 0) {\r
846 break;\r
847 }\r
848\r
849 if ((AltStatusValue & (ATA_STSREG_BSY | ATA_STSREG_ERR)) == ATA_STSREG_ERR) {\r
850 ErrValue = IoRead8 (IdeIoRegisters->Reg1.Error);\r
851 if ((ErrValue & ATA_ERRREG_ABRT) == ATA_ERRREG_ABRT) {\r
852 return EFI_ABORTED;\r
853 }\r
854 }\r
855 \r
856 MicroSecondDelay (250);\r
857\r
858 Delay--;\r
859 } while (Delay != 0);\r
860\r
861 if (Delay == 0) {\r
862 return EFI_TIMEOUT;\r
863 }\r
864\r
865 return EFI_SUCCESS;\r
866}\r
867\r
868/**\r
869 Wait specified time interval to poll for DRQ bit set in the Status Register.\r
870\r
871 @param[in] AtapiBlkIoDev A pointer to atapi block IO device.\r
872 @param[in] IdeIoRegisters A pointer to IDE IO registers.\r
873 @param[in] TimeoutInMilliSeconds Time specified in milliseconds.\r
874\r
875 @retval EFI_SUCCESS DRQ bit is set in the specified time interval.\r
876 @retval EFI_TIMEOUT DRQ bit is not set in the specified time interval.\r
877 @retval EFI_ABORTED Operation Aborted.\r
878\r
879**/\r
880EFI_STATUS\r
881DRQReady (\r
882 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,\r
883 IN IDE_BASE_REGISTERS *IdeIoRegisters,\r
884 IN UINTN TimeoutInMilliSeconds\r
885 )\r
886{\r
887 UINTN Delay;\r
888 UINT16 StatusRegister;\r
889 UINT8 StatusValue;\r
890 UINT8 ErrValue;\r
891\r
892 StatusValue = 0;\r
893 ErrValue = 0;\r
894\r
895 StatusRegister = IdeIoRegisters->Reg.Status;\r
896\r
897 Delay = ((TimeoutInMilliSeconds * STALL_1_MILLI_SECOND) / 250) + 1;\r
898 do {\r
899 //\r
900 // read Status Register will clear interrupt\r
901 //\r
902 StatusValue = IoRead8 (StatusRegister);\r
903\r
904 //\r
905 // BSY==0,DRQ==1\r
906 //\r
907 if ((StatusValue & (ATA_STSREG_BSY | ATA_STSREG_DRQ)) == ATA_STSREG_DRQ) {\r
908 break;\r
909 }\r
910\r
911 if ((StatusValue & (ATA_STSREG_BSY | ATA_STSREG_ERR)) == ATA_STSREG_ERR) {\r
912\r
913 ErrValue = IoRead8 (IdeIoRegisters->Reg1.Error);\r
914 if ((ErrValue & ATA_ERRREG_ABRT) == ATA_ERRREG_ABRT) {\r
915 return EFI_ABORTED;\r
916 }\r
917 }\r
918 MicroSecondDelay (250);\r
919\r
920 Delay--;\r
921 } while (Delay != 0);\r
922\r
923 if (Delay == 0) {\r
924 return EFI_TIMEOUT;\r
925 }\r
926\r
927 return EFI_SUCCESS;\r
928}\r
929\r
930/**\r
931 Wait specified time interval to poll for DRQ bit set in the Alternate Status Register.\r
932\r
933 @param[in] AtapiBlkIoDev A pointer to atapi block IO device.\r
934 @param[in] IdeIoRegisters A pointer to IDE IO registers.\r
935 @param[in] TimeoutInMilliSeconds Time specified in milliseconds.\r
936\r
937 @retval EFI_SUCCESS DRQ bit is set in the specified time interval.\r
938 @retval EFI_TIMEOUT DRQ bit is not set in the specified time interval.\r
939 @retval EFI_ABORTED Operation Aborted.\r
940\r
941**/\r
942EFI_STATUS\r
943DRQReady2 (\r
944 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,\r
945 IN IDE_BASE_REGISTERS *IdeIoRegisters,\r
946 IN UINTN TimeoutInMilliSeconds\r
947 )\r
948{\r
949 UINTN Delay;\r
950 UINT16 AltStatusRegister;\r
951 UINT8 AltStatusValue;\r
952 UINT8 ErrValue;\r
953\r
954 AltStatusValue = 0;\r
955\r
956 AltStatusRegister = IdeIoRegisters->Alt.AltStatus;\r
957\r
958 Delay = ((TimeoutInMilliSeconds * STALL_1_MILLI_SECOND) / 250) + 1;\r
959 do {\r
960\r
961 AltStatusValue = IoRead8 (AltStatusRegister);\r
962\r
963 //\r
964 // BSY==0,DRQ==1\r
965 //\r
966 if ((AltStatusValue & (ATA_STSREG_BSY | ATA_STSREG_DRQ)) == ATA_STSREG_DRQ) {\r
967 break;\r
968 }\r
969\r
970 if ((AltStatusValue & (ATA_STSREG_BSY | ATA_STSREG_ERR)) == ATA_STSREG_ERR) {\r
971\r
972 ErrValue = IoRead8 (IdeIoRegisters->Reg1.Error);\r
973 if ((ErrValue & ATA_ERRREG_ABRT) == ATA_ERRREG_ABRT) {\r
974 return EFI_ABORTED;\r
975 }\r
976 }\r
977 MicroSecondDelay (250);\r
978\r
979 Delay--;\r
980 } while (Delay != 0);\r
981\r
982 if (Delay == 0) {\r
983 return EFI_TIMEOUT;\r
984 }\r
985\r
986 return EFI_SUCCESS;\r
987}\r
988\r
989/**\r
990 Check if there is an error in Status Register.\r
991\r
992 @param[in] AtapiBlkIoDev A pointer to atapi block IO device.\r
993 @param[in] StatusReg The address to IDE IO registers.\r
994\r
995 @retval EFI_SUCCESS Operation success.\r
996 @retval EFI_DEVICE_ERROR Device error.\r
997\r
998**/\r
999EFI_STATUS\r
1000CheckErrorStatus (\r
1001 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,\r
1002 IN UINT16 StatusReg\r
1003 )\r
1004{\r
1005 UINT8 StatusValue;\r
1006\r
1007 StatusValue = IoRead8 (StatusReg);\r
1008\r
1009 if ((StatusValue & (ATA_STSREG_ERR | ATA_STSREG_DWF | ATA_STSREG_CORR)) == 0) {\r
1010\r
1011 return EFI_SUCCESS;\r
1012 }\r
1013\r
1014 return EFI_DEVICE_ERROR;\r
1015\r
1016}\r
1017\r
1018/**\r
1019 Idendify Atapi devices.\r
1020\r
1021 @param[in] AtapiBlkIoDev A pointer to atapi block IO device.\r
1022 @param[in] DevicePosition An integer to signify device position.\r
1023\r
1024 @retval EFI_SUCCESS Identify successfully.\r
1025 @retval EFI_DEVICE_ERROR Device cannot be identified successfully.\r
1026\r
1027**/\r
1028EFI_STATUS\r
1029ATAPIIdentify (\r
1030 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,\r
1031 IN UINTN DevicePosition\r
1032 )\r
1033{\r
1034 ATAPI_IDENTIFY_DATA AtapiIdentifyData;\r
1035 UINT8 Channel;\r
1036 UINT8 Device;\r
1037 UINT16 StatusReg;\r
1038 UINT16 HeadReg;\r
1039 UINT16 CommandReg;\r
1040 UINT16 DataReg;\r
1041 UINT16 SectorCountReg;\r
1042 UINT16 SectorNumberReg;\r
1043 UINT16 CylinderLsbReg;\r
1044 UINT16 CylinderMsbReg;\r
1045\r
1046 UINT32 WordCount;\r
1047 UINT32 Increment;\r
1048 UINT32 Index;\r
1049 UINT32 ByteCount;\r
1050 UINT16 *Buffer16;\r
1051\r
1052 EFI_STATUS Status;\r
1053\r
1054 ByteCount = sizeof (AtapiIdentifyData);\r
1055 Buffer16 = (UINT16 *) &AtapiIdentifyData;\r
1056\r
1057 Channel = (UINT8) (DevicePosition / 2);\r
1058 Device = (UINT8) (DevicePosition % 2);\r
1059\r
1060 ASSERT (Channel < MAX_IDE_CHANNELS);\r
1061\r
1062 StatusReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg.Status;\r
1063 HeadReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Head;\r
1064 CommandReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg.Command;\r
1065 DataReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Data;\r
1066 SectorCountReg = AtapiBlkIoDev->IdeIoPortReg[Channel].SectorCount;\r
1067 SectorNumberReg = AtapiBlkIoDev->IdeIoPortReg[Channel].SectorNumber;\r
1068 CylinderLsbReg = AtapiBlkIoDev->IdeIoPortReg[Channel].CylinderLsb;\r
1069 CylinderMsbReg = AtapiBlkIoDev->IdeIoPortReg[Channel].CylinderMsb;\r
1070\r
1071 //\r
1072 // Send ATAPI Identify Command to get IDENTIFY data.\r
1073 //\r
1074 if (WaitForBSYClear (\r
1075 AtapiBlkIoDev,\r
1076 &(AtapiBlkIoDev->IdeIoPortReg[Channel]),\r
1077 ATATIMEOUT\r
1078 ) != EFI_SUCCESS) {\r
1079 return EFI_DEVICE_ERROR;\r
1080 }\r
1081 //\r
1082 // select device via Head/Device register.\r
1083 // Before write Head/Device register, BSY and DRQ must be 0.\r
1084 //\r
1085 if (DRQClear2 (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), ATATIMEOUT) != EFI_SUCCESS) {\r
1086 return EFI_DEVICE_ERROR;\r
1087 }\r
1088 //\r
1089 // e0:1110,0000-- bit7 and bit5 are reserved bits.\r
1090 // bit6 set means LBA mode\r
1091 //\r
1092 IoWrite8 (HeadReg, (UINT8) ((Device << 4) | 0xe0));\r
1093\r
1094 //\r
1095 // set all the command parameters\r
1096 // Before write to all the following registers, BSY and DRQ must be 0.\r
1097 //\r
1098 if (DRQClear2 (\r
1099 AtapiBlkIoDev,\r
1100 &(AtapiBlkIoDev->IdeIoPortReg[Channel]),\r
1101 ATATIMEOUT\r
1102 ) != EFI_SUCCESS) {\r
1103\r
1104 return EFI_DEVICE_ERROR;\r
1105 }\r
1106\r
1107 IoWrite8 (SectorCountReg, 0);\r
1108 IoWrite8 (SectorNumberReg, 0);\r
1109 IoWrite8 (CylinderLsbReg, 0);\r
1110 IoWrite8 (CylinderMsbReg, 0);\r
1111\r
1112 //\r
1113 // send command via Command Register\r
1114 //\r
1115 IoWrite8 (CommandReg, ATA_CMD_IDENTIFY_DEVICE);\r
1116\r
1117 //\r
1118 // According to PIO data in protocol, host can perform a series of reads to the\r
1119 // data register after each time device set DRQ ready;\r
1120 // The data size of "a series of read" is command specific.\r
1121 // For most ATA command, data size received from device will not exceed 1 sector,\r
1122 // hense the data size for "a series of read" can be the whole data size of one command request.\r
1123 // For ATA command such as Read Sector command, whole data size of one ATA command request is often larger\r
1124 // than 1 sector, according to the Read Sector command, the data size of "a series of read" is exactly\r
1125 // 1 sector.\r
1126 // Here for simplification reason, we specify the data size for "a series of read" to\r
1127 // 1 sector (256 words) if whole data size of one ATA commmand request is larger than 256 words.\r
1128 //\r
1129 Increment = 256;\r
1130 //\r
1131 // 256 words\r
1132 //\r
1133 WordCount = 0;\r
1134 //\r
1135 // WordCount is used to record bytes of currently transfered data\r
1136 //\r
1137 while (WordCount < ByteCount / 2) {\r
1138 //\r
1139 // Poll DRQ bit set, data transfer can be performed only when DRQ is ready.\r
1140 //\r
1141 Status = DRQReady2 (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), ATATIMEOUT);\r
1142 if (Status != EFI_SUCCESS) {\r
1143 return Status;\r
1144 }\r
1145\r
1146 if (CheckErrorStatus (AtapiBlkIoDev, StatusReg) != EFI_SUCCESS) {\r
1147\r
1148 return EFI_DEVICE_ERROR;\r
1149 }\r
1150 //\r
1151 // Get the byte count for one series of read\r
1152 //\r
1153 if ((WordCount + Increment) > ByteCount / 2) {\r
1154 Increment = ByteCount / 2 - WordCount;\r
1155 }\r
1156 //\r
1157 // perform a series of read without check DRQ ready\r
1158 //\r
1159 for (Index = 0; Index < Increment; Index++) {\r
1160 *Buffer16++ = IoRead16 (DataReg);\r
1161 }\r
1162\r
1163 WordCount += Increment;\r
1164\r
1165 }\r
1166 //\r
1167 // while\r
1168 //\r
1169 if (DRQClear (\r
1170 AtapiBlkIoDev,\r
1171 &(AtapiBlkIoDev->IdeIoPortReg[Channel]),\r
1172 ATATIMEOUT\r
1173 ) != EFI_SUCCESS) {\r
1174 return CheckErrorStatus (AtapiBlkIoDev, StatusReg);\r
1175 }\r
1176\r
1177 return EFI_SUCCESS;\r
1178\r
1179}\r
1180\r
1181/**\r
1182 Sends out ATAPI Test Unit Ready Packet Command to the specified device\r
1183 to find out whether device is accessible.\r
1184\r
1185 @param[in] AtapiBlkIoDev A pointer to atapi block IO device.\r
1186 @param[in] DevicePosition An integer to signify device position.\r
1187\r
1188 @retval EFI_SUCCESS TestUnit command executed successfully.\r
1189 @retval EFI_DEVICE_ERROR Device cannot be executed TestUnit command successfully.\r
1190\r
1191**/\r
1192EFI_STATUS\r
1193TestUnitReady (\r
1194 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,\r
1195 IN UINTN DevicePosition\r
1196 )\r
1197{\r
1198 ATAPI_PACKET_COMMAND Packet;\r
1199 EFI_STATUS Status;\r
1200\r
1201 //\r
1202 // fill command packet\r
1203 //\r
1204 ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND));\r
1205 Packet.TestUnitReady.opcode = ATA_CMD_TEST_UNIT_READY;\r
1206\r
1207 //\r
1208 // send command packet\r
1209 //\r
1210 Status = AtapiPacketCommandIn (AtapiBlkIoDev, DevicePosition, &Packet, NULL, 0, ATAPITIMEOUT);\r
1211 return Status;\r
1212}\r
1213\r
1214/**\r
1215 Send out ATAPI commands conforms to the Packet Command with PIO Data In Protocol.\r
1216 \r
1217 @param[in] AtapiBlkIoDev A pointer to atapi block IO device.\r
1218 @param[in] DevicePosition An integer to signify device position.\r
1219 @param[in] Packet A pointer to ATAPI command packet.\r
1220 @param[in] Buffer Buffer to contain requested transfer data from device.\r
1221 @param[in] ByteCount Requested transfer data length.\r
1222 @param[in] TimeoutInMilliSeconds Time out value, in unit of milliseconds.\r
1223\r
1224 @retval EFI_SUCCESS Command executed successfully.\r
1225 @retval EFI_DEVICE_ERROR Device cannot be executed command successfully.\r
1226\r
1227**/\r
1228EFI_STATUS\r
1229AtapiPacketCommandIn (\r
1230 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,\r
1231 IN UINTN DevicePosition,\r
1232 IN ATAPI_PACKET_COMMAND *Packet,\r
1233 IN UINT16 *Buffer,\r
1234 IN UINT32 ByteCount,\r
1235 IN UINTN TimeoutInMilliSeconds\r
1236 )\r
1237{\r
1238 UINT8 Channel;\r
1239 UINT8 Device;\r
1240 UINT16 StatusReg;\r
1241 UINT16 HeadReg;\r
1242 UINT16 CommandReg;\r
1243 UINT16 FeatureReg;\r
1244 UINT16 CylinderLsbReg;\r
1245 UINT16 CylinderMsbReg;\r
1246 UINT16 DeviceControlReg;\r
1247 UINT16 DataReg;\r
1248 EFI_STATUS Status;\r
1249 UINT32 Count;\r
1250 UINT16 *CommandIndex;\r
1251 UINT16 *PtrBuffer;\r
1252 UINT32 Index;\r
1253 UINT8 StatusValue;\r
1254 UINT32 WordCount;\r
1255\r
1256 //\r
1257 // required transfer data in word unit.\r
1258 //\r
1259 UINT32 RequiredWordCount;\r
1260\r
1261 //\r
1262 // actual transfer data in word unit.\r
1263 //\r
1264 UINT32 ActualWordCount;\r
1265\r
1266 Channel = (UINT8) (DevicePosition / 2);\r
1267 Device = (UINT8) (DevicePosition % 2);\r
1268\r
1269 ASSERT (Channel < MAX_IDE_CHANNELS);\r
1270\r
1271 StatusReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg.Status;\r
1272 HeadReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Head;\r
1273 CommandReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg.Command;\r
1274 FeatureReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg1.Feature;\r
1275 CylinderLsbReg = AtapiBlkIoDev->IdeIoPortReg[Channel].CylinderLsb;\r
1276 CylinderMsbReg = AtapiBlkIoDev->IdeIoPortReg[Channel].CylinderMsb;\r
1277 DeviceControlReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Alt.DeviceControl;\r
1278 DataReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Data;\r
1279\r
1280 //\r
1281 // Set all the command parameters by fill related registers.\r
1282 // Before write to all the following registers, BSY and DRQ must be 0.\r
1283 //\r
1284 if (DRQClear2 (\r
1285 AtapiBlkIoDev,\r
1286 &(AtapiBlkIoDev->IdeIoPortReg[Channel]),\r
1287 ATATIMEOUT\r
1288 ) != EFI_SUCCESS) {\r
1289 return EFI_DEVICE_ERROR;\r
1290 }\r
1291 //\r
1292 // Select device via Device/Head Register.\r
1293 // DEFAULT_CMD: 0xa0 (1010,0000)\r
1294 //\r
1295 IoWrite8 (HeadReg, (UINT8) ((Device << 4) | ATA_DEFAULT_CMD));\r
1296\r
1297 //\r
1298 // No OVL; No DMA\r
1299 //\r
1300 IoWrite8 (FeatureReg, 0x00);\r
1301\r
1302 //\r
1303 // set the transfersize to MAX_ATAPI_BYTE_COUNT to let the device\r
1304 // determine how many data should be transfered.\r
1305 //\r
1306 IoWrite8 (CylinderLsbReg, (UINT8) (ATAPI_MAX_BYTE_COUNT & 0x00ff));\r
1307 IoWrite8 (CylinderMsbReg, (UINT8) (ATAPI_MAX_BYTE_COUNT >> 8));\r
1308\r
1309 //\r
1310 // DEFAULT_CTL:0x0a (0000,1010)\r
1311 // Disable interrupt\r
1312 //\r
1313 IoWrite8 (DeviceControlReg, ATA_DEFAULT_CTL);\r
1314\r
1315 //\r
1316 // Send Packet command to inform device\r
1317 // that the following data bytes are command packet.\r
1318 //\r
1319 IoWrite8 (CommandReg, ATA_CMD_PACKET);\r
1320\r
1321 Status = DRQReady (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), TimeoutInMilliSeconds);\r
1322 if (Status != EFI_SUCCESS) {\r
1323 return Status;\r
1324 }\r
1325 //\r
1326 // Send out command packet\r
1327 //\r
1328 CommandIndex = Packet->Data16;\r
1329 for (Count = 0; Count < 6; Count++, CommandIndex++) {\r
1330 IoWrite16 (DataReg, *CommandIndex);\r
1331 MicroSecondDelay (10);\r
1332 }\r
1333\r
1334 StatusValue = IoRead8 (StatusReg);\r
1335 if ((StatusValue & ATA_STSREG_ERR) == ATA_STSREG_ERR) {\r
1336 //\r
1337 // Trouble! Something's wrong here... Wait some time and return. 3 second is\r
1338 // supposed to be long enough for a device reset latency or error recovery\r
1339 //\r
1340 MicroSecondDelay (3000000);\r
1341 return EFI_DEVICE_ERROR;\r
1342 }\r
1343\r
1344 if (Buffer == NULL || ByteCount == 0) {\r
1345 return EFI_SUCCESS;\r
1346 }\r
1347 //\r
1348 // call PioReadWriteData() function to get\r
1349 // requested transfer data form device.\r
1350 //\r
1351 PtrBuffer = Buffer;\r
1352 RequiredWordCount = ByteCount / 2;\r
1353 //\r
1354 // ActuralWordCount means the word count of data really transfered.\r
1355 //\r
1356 ActualWordCount = 0;\r
1357\r
1358 Status = EFI_SUCCESS;\r
1359 while ((Status == EFI_SUCCESS) && (ActualWordCount < RequiredWordCount)) {\r
1360 //\r
1361 // before each data transfer stream, the host should poll DRQ bit ready,\r
1362 // which informs device is ready to transfer data.\r
1363 //\r
1364 if (DRQReady2 (\r
1365 AtapiBlkIoDev,\r
1366 &(AtapiBlkIoDev->IdeIoPortReg[Channel]),\r
1367 TimeoutInMilliSeconds\r
1368 ) != EFI_SUCCESS) {\r
1369 return CheckErrorStatus (AtapiBlkIoDev, StatusReg);\r
1370 }\r
1371 //\r
1372 // read Status Register will clear interrupt\r
1373 //\r
1374 StatusValue = IoRead8 (StatusReg);\r
1375\r
1376 //\r
1377 // get current data transfer size from Cylinder Registers.\r
1378 //\r
1379 WordCount = IoRead8 (CylinderMsbReg) << 8;\r
1380 WordCount = WordCount | IoRead8 (CylinderLsbReg);\r
1381 WordCount = WordCount & 0xffff;\r
1382 WordCount /= 2;\r
1383\r
1384 //\r
1385 // perform a series data In/Out.\r
1386 //\r
1387 for (Index = 0; (Index < WordCount) && (ActualWordCount < RequiredWordCount); Index++, ActualWordCount++) {\r
1388\r
1389 *PtrBuffer = IoRead16 (DataReg);\r
1390\r
1391 PtrBuffer++;\r
1392\r
1393 }\r
1394\r
1395 if (((ATAPI_REQUEST_SENSE_CMD *) Packet)->opcode == ATA_CMD_REQUEST_SENSE && ActualWordCount >= 4) {\r
1396 RequiredWordCount = MIN (\r
1397 RequiredWordCount,\r
1398 (UINT32) (4 + (((ATAPI_REQUEST_SENSE_DATA *) Buffer)->addnl_sense_length / 2))\r
1399 );\r
1400 }\r
1401\r
1402 }\r
1403 //\r
1404 // After data transfer is completed, normally, DRQ bit should clear.\r
1405 //\r
1406 Status = DRQClear2 (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), TimeoutInMilliSeconds);\r
1407 if (Status != EFI_SUCCESS) {\r
1408 return EFI_DEVICE_ERROR;\r
1409 }\r
1410 //\r
1411 // read status register to check whether error happens.\r
1412 //\r
1413 Status = CheckErrorStatus (AtapiBlkIoDev, StatusReg);\r
1414 return Status;\r
1415}\r
1416\r
1417/**\r
1418 Sends out ATAPI Inquiry Packet Command to the specified device.\r
1419 This command will return INQUIRY data of the device.\r
1420\r
1421 @param[in] AtapiBlkIoDev A pointer to atapi block IO device.\r
1422 @param[in] DevicePosition An integer to signify device position.\r
1423 @param[out] MediaInfo The media information of the specified block media.\r
1424\r
1425 @retval EFI_SUCCESS Command executed successfully.\r
1426 @retval EFI_DEVICE_ERROR Device cannot be executed command successfully.\r
1427 @retval EFI_UNSUPPORTED Unsupported device type.\r
1428\r
1429**/\r
1430EFI_STATUS\r
1431Inquiry (\r
1432 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,\r
1433 IN UINTN DevicePosition,\r
1434 OUT EFI_PEI_BLOCK_IO_MEDIA *MediaInfo\r
1435 )\r
1436{\r
1437 ATAPI_PACKET_COMMAND Packet;\r
1438 EFI_STATUS Status;\r
1439 ATAPI_INQUIRY_DATA Idata;\r
1440\r
1441 //\r
1442 // prepare command packet for the ATAPI Inquiry Packet Command.\r
1443 //\r
1444 ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND));\r
523f48e7 1445 ZeroMem (&Idata, sizeof (ATAPI_INQUIRY_DATA));\r
ea060cfa 1446\r
1447 Packet.Inquiry.opcode = ATA_CMD_INQUIRY;\r
1448 Packet.Inquiry.page_code = 0;\r
1449 Packet.Inquiry.allocation_length = (UINT8) sizeof (ATAPI_INQUIRY_DATA);\r
1450\r
1451 //\r
1452 // Send command packet and get requested Inquiry data.\r
1453 //\r
1454 Status = AtapiPacketCommandIn (\r
1455 AtapiBlkIoDev,\r
1456 DevicePosition,\r
1457 &Packet,\r
1458 (UINT16 *) (&Idata),\r
1459 sizeof (ATAPI_INQUIRY_DATA),\r
1460 ATAPITIMEOUT\r
1461 //50\r
1462 );\r
1463\r
1464 if (Status != EFI_SUCCESS) {\r
1465 return EFI_DEVICE_ERROR;\r
1466 }\r
1467 //\r
1468 // Identify device type via INQUIRY data.\r
1469 //\r
1470 switch (Idata.peripheral_type & 0x1f) {\r
1471 case 0x00:\r
1472 //\r
1473 // Magnetic Disk\r
1474 //\r
1475 MediaInfo->DeviceType = IdeLS120;\r
1476 MediaInfo->MediaPresent = FALSE;\r
1477 MediaInfo->LastBlock = 0;\r
1478 MediaInfo->BlockSize = 0x200;\r
1479 break;\r
1480\r
1481 case 0x05:\r
1482 //\r
1483 // CD-ROM\r
1484 //\r
1485 MediaInfo->DeviceType = IdeCDROM;\r
1486 MediaInfo->MediaPresent = FALSE;\r
1487 MediaInfo->LastBlock = 0;\r
1488 MediaInfo->BlockSize = 0x800;\r
1489 break;\r
1490\r
1491 default:\r
1492 return EFI_UNSUPPORTED;\r
1493 }\r
1494\r
1495 return EFI_SUCCESS;\r
1496}\r
1497\r
1498/** \r
1499 Used before read/write blocks from/to ATAPI device media. \r
1500 Since ATAPI device media is removable, it is necessary to detect\r
1501 whether media is present and get current present media's information.\r
1502\r
1503 @param[in] AtapiBlkIoDev A pointer to atapi block IO device.\r
1504 @param[in] DevicePosition An integer to signify device position.\r
1505 @param[in, out] MediaInfo The media information of the specified block media.\r
1506\r
1507 @retval EFI_SUCCESS Command executed successfully.\r
1508 @retval EFI_DEVICE_ERROR Some device errors happen.\r
1509 @retval EFI_OUT_OF_RESOURCES Can not allocate required resources.\r
1510\r
1511**/\r
1512EFI_STATUS\r
1513DetectMedia (\r
1514 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,\r
1515 IN UINTN DevicePosition,\r
1516 IN OUT EFI_PEI_BLOCK_IO_MEDIA *MediaInfo\r
1517 )\r
1518{\r
1519\r
1520 UINTN Index;\r
1521 UINTN RetryNum;\r
1522 UINTN MaxRetryNum;\r
1523 ATAPI_REQUEST_SENSE_DATA *SenseBuffers;\r
1524 BOOLEAN NeedReadCapacity;\r
1525 BOOLEAN NeedRetry;\r
1526 EFI_STATUS Status;\r
1527 UINT8 SenseCounts;\r
1528\r
1529 SenseBuffers = AllocatePages (EFI_SIZE_TO_PAGES (sizeof (*SenseBuffers)));\r
1530 if (SenseBuffers == NULL) {\r
1531 return EFI_OUT_OF_RESOURCES;\r
1532 }\r
1533 \r
1534 //\r
1535 // Test Unit Ready command is used to detect whether device is accessible,\r
1536 // the device will produce corresponding Sense data.\r
1537 //\r
1538 for (Index = 0; Index < 2; Index++) {\r
1539\r
1540 Status = TestUnitReady (AtapiBlkIoDev, DevicePosition);\r
1541 if (Status != EFI_SUCCESS) {\r
1542 Status = ResetDevice (AtapiBlkIoDev, DevicePosition, FALSE);\r
1543\r
1544 if (Status != EFI_SUCCESS) {\r
1545 ResetDevice (AtapiBlkIoDev, DevicePosition, TRUE);\r
1546 }\r
1547\r
1548 } else {\r
1549 break;\r
1550 }\r
1551 }\r
1552\r
1553 SenseCounts = MAX_SENSE_KEY_COUNT;\r
1554 Status = EFI_SUCCESS;\r
1555 NeedReadCapacity = TRUE;\r
1556\r
1557 for (Index = 0; Index < 5; Index++) {\r
1558 SenseCounts = MAX_SENSE_KEY_COUNT;\r
1559 Status = RequestSense (\r
1560 AtapiBlkIoDev,\r
1561 DevicePosition,\r
1562 SenseBuffers,\r
1563 &SenseCounts\r
1564 );\r
1565 DEBUG ((EFI_D_INFO, "Atapi Request Sense Count is %d\n", SenseCounts));\r
1566 if (IsDeviceStateUnclear (SenseBuffers, SenseCounts) || IsNoMedia (SenseBuffers, SenseCounts)) {\r
1567 //\r
1568 // We are not sure whether the media is present or not, try again\r
1569 //\r
1570 TestUnitReady (AtapiBlkIoDev, DevicePosition);\r
1571 } else {\r
1572 break;\r
1573 }\r
1574 }\r
1575\r
1576 if (Status == EFI_SUCCESS) {\r
1577\r
1578 if (IsNoMedia (SenseBuffers, SenseCounts)) {\r
1579\r
1580 NeedReadCapacity = FALSE;\r
1581 MediaInfo->MediaPresent = FALSE;\r
1582 MediaInfo->LastBlock = 0;\r
1583 }\r
1584\r
1585 if (IsMediaError (SenseBuffers, SenseCounts)) {\r
1586 return EFI_DEVICE_ERROR;\r
1587 }\r
1588 }\r
1589\r
1590 if (NeedReadCapacity) {\r
1591 //\r
1592 // at most retry 5 times\r
1593 //\r
1594 MaxRetryNum = 5;\r
1595 RetryNum = 1;\r
1596 //\r
1597 // initial retry once\r
1598 //\r
1599 for (Index = 0; (Index < RetryNum) && (Index < MaxRetryNum); Index++) {\r
1600\r
1601 Status = ReadCapacity (AtapiBlkIoDev, DevicePosition, MediaInfo);\r
1602 MicroSecondDelay (200000);\r
1603 SenseCounts = MAX_SENSE_KEY_COUNT;\r
1604\r
1605 if (Status != EFI_SUCCESS) {\r
1606\r
1607 Status = RequestSense (AtapiBlkIoDev, DevicePosition, SenseBuffers, &SenseCounts);\r
1608 //\r
1609 // If Request Sense data failed, reset the device and retry.\r
1610 //\r
1611 if (Status != EFI_SUCCESS) {\r
1612\r
1613 Status = ResetDevice (AtapiBlkIoDev, DevicePosition, FALSE);\r
1614 //\r
1615 // if ATAPI soft reset fail,\r
1616 // use stronger reset mechanism -- ATA soft reset.\r
1617 //\r
1618 if (Status != EFI_SUCCESS) {\r
1619 ResetDevice (AtapiBlkIoDev, DevicePosition, TRUE);\r
1620 }\r
1621\r
1622 RetryNum++;\r
1623 //\r
1624 // retry once more\r
1625 //\r
1626 continue;\r
1627 }\r
1628 //\r
1629 // No Media\r
1630 //\r
1631 if (IsNoMedia (SenseBuffers, SenseCounts)) {\r
1632\r
1633 MediaInfo->MediaPresent = FALSE;\r
1634 MediaInfo->LastBlock = 0;\r
1635 break;\r
1636 }\r
1637\r
1638 if (IsMediaError (SenseBuffers, SenseCounts)) {\r
1639 return EFI_DEVICE_ERROR;\r
1640 }\r
1641\r
1642 if (!IsDriveReady (SenseBuffers, SenseCounts, &NeedRetry)) {\r
1643 //\r
1644 // Drive not ready: if NeedRetry, then retry once more;\r
1645 // else return error\r
1646 //\r
1647 if (NeedRetry) {\r
1648 RetryNum++;\r
1649 continue;\r
1650 } else {\r
1651 return EFI_DEVICE_ERROR;\r
1652 }\r
1653 }\r
1654 //\r
1655 // if read capacity fail not for above reasons, retry once more\r
1656 //\r
1657 RetryNum++;\r
1658\r
1659 }\r
1660\r
1661 }\r
1662\r
1663 }\r
1664\r
1665 return EFI_SUCCESS;\r
1666}\r
1667\r
1668/** \r
1669 Reset specified Atapi device.\r
1670\r
1671 @param[in] AtapiBlkIoDev A pointer to atapi block IO device.\r
1672 @param[in] DevicePosition An integer to signify device position.\r
1673 @param[in] Extensive If TRUE, use ATA soft reset, otherwise use Atapi soft reset.\r
1674\r
1675 @retval EFI_SUCCESS Command executed successfully.\r
1676 @retval EFI_DEVICE_ERROR Some device errors happen.\r
1677\r
1678**/\r
1679EFI_STATUS\r
1680ResetDevice (\r
1681 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,\r
1682 IN UINTN DevicePosition,\r
1683 IN BOOLEAN Extensive\r
1684 )\r
1685{\r
1686 UINT8 DevControl;\r
1687 UINT8 Command;\r
1688 UINT8 DeviceSelect;\r
1689 UINT16 DeviceControlReg;\r
1690 UINT16 CommandReg;\r
1691 UINT16 HeadReg;\r
1692 UINT8 Channel;\r
1693 UINT8 Device;\r
1694\r
1695 Channel = (UINT8) (DevicePosition / 2);\r
1696 Device = (UINT8) (DevicePosition % 2);\r
1697\r
1698 ASSERT (Channel < MAX_IDE_CHANNELS);\r
1699\r
1700 DeviceControlReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Alt.DeviceControl;\r
1701 CommandReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Reg.Command;\r
1702 HeadReg = AtapiBlkIoDev->IdeIoPortReg[Channel].Head;\r
1703\r
1704 if (Extensive) {\r
1705\r
1706 DevControl = 0;\r
1707 DevControl |= ATA_CTLREG_SRST;\r
1708 //\r
1709 // set SRST bit to initiate soft reset\r
1710 //\r
1711 DevControl |= BIT1;\r
1712 //\r
1713 // disable Interrupt\r
1714 //\r
1715 IoWrite8 (DeviceControlReg, DevControl);\r
1716\r
1717 //\r
1718 // Wait 10us\r
1719 //\r
1720 MicroSecondDelay (10);\r
1721\r
1722 //\r
1723 // Clear SRST bit\r
1724 //\r
1725 DevControl &= 0xfb;\r
1726 //\r
1727 // 0xfb:1111,1011\r
1728 //\r
1729 IoWrite8 (DeviceControlReg, DevControl);\r
1730\r
1731 //\r
1732 // slave device needs at most 31s to clear BSY\r
1733 //\r
1734 if (WaitForBSYClear (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), 31000) == EFI_TIMEOUT) {\r
1735 return EFI_DEVICE_ERROR;\r
1736 }\r
1737\r
1738 } else {\r
1739 //\r
1740 // for ATAPI device, no need to wait DRDY ready after device selecting.\r
1741 // bit7 and bit5 are both set to 1 for backward compatibility\r
1742 //\r
1743 DeviceSelect = (UINT8) (((BIT7 | BIT5) | (Device << 4)));\r
1744 IoWrite8 (HeadReg, DeviceSelect);\r
1745\r
1746 Command = ATA_CMD_SOFT_RESET;\r
1747 IoWrite8 (CommandReg, Command);\r
1748\r
1749 //\r
1750 // BSY cleared is the only status return to the host by the device when reset is completed\r
1751 // slave device needs at most 31s to clear BSY\r
1752 //\r
1753 if (WaitForBSYClear (AtapiBlkIoDev, &(AtapiBlkIoDev->IdeIoPortReg[Channel]), 31000) != EFI_SUCCESS) {\r
1754 return EFI_DEVICE_ERROR;\r
1755 }\r
1756 //\r
1757 // stall 5 seconds to make the device status stable\r
1758 //\r
1759 MicroSecondDelay (STALL_1_SECONDS * 5);\r
1760 }\r
1761\r
1762 return EFI_SUCCESS;\r
1763\r
1764}\r
1765\r
1766/** \r
1767 Sends out ATAPI Request Sense Packet Command to the specified device.\r
1768\r
1769 @param[in] AtapiBlkIoDev A pointer to atapi block IO device.\r
1770 @param[in] DevicePosition An integer to signify device position.\r
1771 @param[in] SenseBuffers Pointer to sense buffer.\r
1772 @param[in, out] SenseCounts Length of sense buffer.\r
1773\r
1774 @retval EFI_SUCCESS Command executed successfully.\r
1775 @retval EFI_DEVICE_ERROR Some device errors happen.\r
1776\r
1777**/\r
1778EFI_STATUS\r
1779RequestSense (\r
1780 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,\r
1781 IN UINTN DevicePosition,\r
1782 IN ATAPI_REQUEST_SENSE_DATA *SenseBuffers,\r
1783 IN OUT UINT8 *SenseCounts\r
1784 )\r
1785{\r
1786 EFI_STATUS Status;\r
1787 ATAPI_REQUEST_SENSE_DATA *Sense;\r
1788 UINT16 *Ptr;\r
1789 BOOLEAN SenseReq;\r
1790 ATAPI_PACKET_COMMAND Packet;\r
1791\r
1792 ZeroMem (SenseBuffers, sizeof (ATAPI_REQUEST_SENSE_DATA) * (*SenseCounts));\r
1793 //\r
1794 // fill command packet for Request Sense Packet Command\r
1795 //\r
1796 ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND));\r
1797 Packet.RequestSence.opcode = ATA_CMD_REQUEST_SENSE;\r
1798 Packet.RequestSence.allocation_length = (UINT8) sizeof (ATAPI_REQUEST_SENSE_DATA);\r
1799\r
1800 Ptr = (UINT16 *) SenseBuffers;\r
1801 //\r
1802 // initialize pointer\r
1803 //\r
1804 *SenseCounts = 0;\r
1805 //\r
1806 // request sense data from device continiously until no sense data exists in the device.\r
1807 //\r
1808 for (SenseReq = TRUE; SenseReq;) {\r
1809\r
1810 Sense = (ATAPI_REQUEST_SENSE_DATA *) Ptr;\r
1811\r
1812 //\r
1813 // send out Request Sense Packet Command and get one Sense data form device\r
1814 //\r
1815 Status = AtapiPacketCommandIn (\r
1816 AtapiBlkIoDev,\r
1817 DevicePosition,\r
1818 &Packet,\r
1819 Ptr,\r
1820 sizeof (ATAPI_REQUEST_SENSE_DATA),\r
1821 ATAPITIMEOUT\r
1822 );\r
1823 //\r
1824 // failed to get Sense data\r
1825 //\r
1826 if (Status != EFI_SUCCESS) {\r
1827 if (*SenseCounts == 0) {\r
1828 return EFI_DEVICE_ERROR;\r
1829 } else {\r
1830 return EFI_SUCCESS;\r
1831 }\r
1832 }\r
1833\r
1834 (*SenseCounts)++;\r
1835\r
1836 if (*SenseCounts > MAX_SENSE_KEY_COUNT) {\r
1837 return EFI_SUCCESS;\r
1838 }\r
1839 //\r
1840 // We limit MAX sense data count to 20 in order to avoid dead loop. Some\r
1841 // incompatible ATAPI devices don't retrive NO_SENSE when there is no media.\r
1842 // In this case, dead loop occurs if we don't have a gatekeeper. 20 is\r
1843 // supposed to be large enough for any ATAPI device.\r
1844 //\r
1845 if ((Sense->sense_key != ATA_SK_NO_SENSE) && ((*SenseCounts) < 20)) {\r
1846\r
1847 Ptr += sizeof (ATAPI_REQUEST_SENSE_DATA) / 2;\r
1848 //\r
1849 // Ptr is word based pointer\r
1850 //\r
1851 } else {\r
1852 //\r
1853 // when no sense key, skip out the loop\r
1854 //\r
1855 SenseReq = FALSE;\r
1856 }\r
1857 }\r
1858\r
1859 return EFI_SUCCESS;\r
1860}\r
1861\r
1862/** \r
1863 Sends out ATAPI Read Capacity Packet Command to the specified device.\r
1864 This command will return the information regarding the capacity of the\r
1865 media in the device.\r
1866\r
1867 @param[in] AtapiBlkIoDev A pointer to atapi block IO device.\r
1868 @param[in] DevicePosition An integer to signify device position.\r
1869 @param[in, out] MediaInfo The media information of the specified block media.\r
1870\r
1871 @retval EFI_SUCCESS Command executed successfully.\r
1872 @retval EFI_DEVICE_ERROR Some device errors happen.\r
1873\r
1874**/\r
1875EFI_STATUS\r
1876ReadCapacity (\r
1877 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,\r
1878 IN UINTN DevicePosition,\r
1879 IN OUT EFI_PEI_BLOCK_IO_MEDIA *MediaInfo\r
1880 )\r
1881{\r
1882 EFI_STATUS Status;\r
1883 ATAPI_PACKET_COMMAND Packet;\r
1884\r
1885 //\r
1886 // used for capacity data returned from ATAPI device\r
1887 //\r
1888 ATAPI_READ_CAPACITY_DATA Data;\r
1889 ATAPI_READ_FORMAT_CAPACITY_DATA FormatData;\r
1890\r
1891 ZeroMem (&Data, sizeof (Data));\r
1892 ZeroMem (&FormatData, sizeof (FormatData));\r
1893\r
1894 if (MediaInfo->DeviceType == IdeCDROM) {\r
1895\r
1896 ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND));\r
1897 Packet.Inquiry.opcode = ATA_CMD_READ_CAPACITY;\r
1898 Status = AtapiPacketCommandIn (\r
1899 AtapiBlkIoDev,\r
1900 DevicePosition,\r
1901 &Packet,\r
1902 (UINT16 *) (&Data),\r
1903 sizeof (ATAPI_READ_CAPACITY_DATA),\r
1904 ATAPITIMEOUT\r
1905 );\r
1906\r
1907 } else {\r
1908 //\r
1909 // DeviceType == IdeLS120\r
1910 //\r
1911 ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND));\r
1912 Packet.ReadFormatCapacity.opcode = ATA_CMD_READ_FORMAT_CAPACITY;\r
1913 Packet.ReadFormatCapacity.allocation_length_lo = 12;\r
1914 Status = AtapiPacketCommandIn (\r
1915 AtapiBlkIoDev,\r
1916 DevicePosition,\r
1917 &Packet,\r
1918 (UINT16 *) (&FormatData),\r
1919 sizeof (ATAPI_READ_FORMAT_CAPACITY_DATA),\r
1920 ATAPITIMEOUT*10\r
1921 );\r
1922 }\r
1923\r
1924 if (Status == EFI_SUCCESS) {\r
1925\r
1926 if (MediaInfo->DeviceType == IdeCDROM) {\r
1927\r
1928 MediaInfo->LastBlock = (Data.LastLba3 << 24) | (Data.LastLba2 << 16) | (Data.LastLba1 << 8) | Data.LastLba0;\r
1929 MediaInfo->MediaPresent = TRUE;\r
1930 //\r
1931 // Because the user data portion in the sector of the Data CD supported\r
1932 // is always 800h\r
1933 //\r
1934 MediaInfo->BlockSize = 0x800;\r
1935 }\r
1936\r
1937 if (MediaInfo->DeviceType == IdeLS120) {\r
1938\r
1939 if (FormatData.DesCode == 3) {\r
1940 MediaInfo->MediaPresent = FALSE;\r
1941 MediaInfo->LastBlock = 0;\r
1942 } else {\r
1943 MediaInfo->LastBlock = (FormatData.LastLba3 << 24) |\r
1944 (FormatData.LastLba2 << 16) |\r
1945 (FormatData.LastLba1 << 8) |\r
1946 FormatData.LastLba0;\r
1947 MediaInfo->LastBlock--;\r
1948\r
1949 MediaInfo->MediaPresent = TRUE;\r
1950\r
1951 MediaInfo->BlockSize = 0x200;\r
1952\r
1953 }\r
1954 }\r
1955\r
1956 return EFI_SUCCESS;\r
1957\r
1958 } else {\r
1959 return EFI_DEVICE_ERROR;\r
1960 }\r
1961}\r
1962\r
1963/** \r
1964 Perform read from disk in block unit.\r
1965\r
1966 @param[in] AtapiBlkIoDev A pointer to atapi block IO device.\r
1967 @param[in] DevicePosition An integer to signify device position.\r
1968 @param[in] Buffer Buffer to contain read data.\r
1969 @param[in] StartLba Starting LBA address.\r
1970 @param[in] NumberOfBlocks Number of blocks to read.\r
1971 @param[in] BlockSize Size of each block.\r
1972\r
1973 @retval EFI_SUCCESS Command executed successfully.\r
1974 @retval EFI_DEVICE_ERROR Some device errors happen.\r
1975\r
1976**/\r
1977EFI_STATUS\r
1978ReadSectors (\r
1979 IN ATAPI_BLK_IO_DEV *AtapiBlkIoDev,\r
1980 IN UINTN DevicePosition,\r
1981 IN VOID *Buffer,\r
1982 IN EFI_PEI_LBA StartLba,\r
1983 IN UINTN NumberOfBlocks,\r
1984 IN UINTN BlockSize\r
1985 )\r
1986{\r
1987\r
1988 ATAPI_PACKET_COMMAND Packet;\r
1989 ATAPI_READ10_CMD *Read10Packet;\r
1990 EFI_STATUS Status;\r
1991 UINTN BlocksRemaining;\r
1992 UINT32 Lba32;\r
1993 UINT32 ByteCount;\r
1994 UINT16 SectorCount;\r
1995 VOID *PtrBuffer;\r
1996 UINT16 MaxBlock;\r
1997\r
1998 //\r
1999 // fill command packet for Read(10) command\r
2000 //\r
2001 ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND));\r
2002 Read10Packet = &Packet.Read10;\r
2003 Lba32 = (UINT32) StartLba;\r
2004 PtrBuffer = Buffer;\r
2005\r
2006 //\r
2007 // limit the data bytes that can be transfered by one Read(10) Command\r
2008 //\r
2009 MaxBlock = (UINT16) (0x10000 / BlockSize);\r
2010 //\r
2011 // (64k bytes)\r
2012 //\r
2013 BlocksRemaining = NumberOfBlocks;\r
2014\r
2015 Status = EFI_SUCCESS;\r
2016 while (BlocksRemaining > 0) {\r
2017\r
2018 if (BlocksRemaining <= MaxBlock) {\r
2019 SectorCount = (UINT16) BlocksRemaining;\r
2020 } else {\r
2021 SectorCount = MaxBlock;\r
2022 }\r
2023 //\r
2024 // fill the Packet data sturcture\r
2025 //\r
2026 Read10Packet->opcode = ATA_CMD_READ_10;\r
2027\r
2028 //\r
2029 // Lba0 ~ Lba3 specify the start logical block address of the data transfer.\r
2030 // Lba0 is MSB, Lba3 is LSB\r
2031 //\r
2032 Read10Packet->Lba3 = (UINT8) (Lba32 & 0xff);\r
2033 Read10Packet->Lba2 = (UINT8) (Lba32 >> 8);\r
2034 Read10Packet->Lba1 = (UINT8) (Lba32 >> 16);\r
2035 Read10Packet->Lba0 = (UINT8) (Lba32 >> 24);\r
2036\r
2037 //\r
2038 // TranLen0 ~ TranLen1 specify the transfer length in block unit.\r
2039 // TranLen0 is MSB, TranLen is LSB\r
2040 //\r
2041 Read10Packet->TranLen1 = (UINT8) (SectorCount & 0xff);\r
2042 Read10Packet->TranLen0 = (UINT8) (SectorCount >> 8);\r
2043\r
2044 ByteCount = (UINT32) (SectorCount * BlockSize);\r
2045\r
2046 Status = AtapiPacketCommandIn (\r
2047 AtapiBlkIoDev,\r
2048 DevicePosition,\r
2049 &Packet,\r
2050 (UINT16 *) PtrBuffer,\r
2051 ByteCount,\r
2052 ATAPILONGTIMEOUT\r
2053 );\r
2054 if (Status != EFI_SUCCESS) {\r
2055 return Status;\r
2056 }\r
2057\r
2058 Lba32 += SectorCount;\r
2059 PtrBuffer = (UINT8 *) PtrBuffer + SectorCount * BlockSize;\r
2060 BlocksRemaining -= SectorCount;\r
2061 }\r
2062\r
2063 return Status;\r
2064}\r
2065\r
2066/** \r
2067 Check if there is media according to sense data.\r
2068\r
2069 @param[in] SenseData Pointer to sense data.\r
2070 @param[in] SenseCounts Count of sense data.\r
2071\r
2072 @retval TRUE No media\r
2073 @retval FALSE Media exists\r
2074\r
2075**/\r
2076BOOLEAN\r
2077IsNoMedia (\r
2078 IN ATAPI_REQUEST_SENSE_DATA *SenseData,\r
2079 IN UINTN SenseCounts\r
2080 )\r
2081{\r
2082 ATAPI_REQUEST_SENSE_DATA *SensePtr;\r
2083 UINTN Index;\r
2084 BOOLEAN IsNoMedia;\r
2085\r
2086 IsNoMedia = FALSE;\r
2087\r
2088 SensePtr = SenseData;\r
2089\r
2090 for (Index = 0; Index < SenseCounts; Index++) {\r
2091\r
2092 if ((SensePtr->sense_key == ATA_SK_NOT_READY) && (SensePtr->addnl_sense_code == ATA_ASC_NO_MEDIA)) {\r
2093 IsNoMedia = TRUE;\r
2094 }\r
2095\r
2096 SensePtr++;\r
2097 }\r
2098\r
2099 return IsNoMedia;\r
2100}\r
2101\r
2102/** \r
2103 Check if device state is unclear according to sense data.\r
2104\r
2105 @param[in] SenseData Pointer to sense data.\r
2106 @param[in] SenseCounts Count of sense data.\r
2107\r
2108 @retval TRUE Device state is unclear\r
2109 @retval FALSE Device state is clear \r
2110\r
2111**/\r
2112BOOLEAN\r
2113IsDeviceStateUnclear (\r
2114 IN ATAPI_REQUEST_SENSE_DATA *SenseData,\r
2115 IN UINTN SenseCounts\r
2116 )\r
2117{\r
2118 ATAPI_REQUEST_SENSE_DATA *SensePtr;\r
2119 UINTN Index;\r
2120 BOOLEAN Unclear;\r
2121\r
2122 Unclear = FALSE;\r
2123\r
2124 SensePtr = SenseData;\r
2125\r
2126 for (Index = 0; Index < SenseCounts; Index++) {\r
2127\r
2128 if (SensePtr->sense_key == 0x06) {\r
2129 //\r
2130 // Sense key is 0x06 means the device is just be reset or media just\r
2131 // changed. The current state of the device is unclear.\r
2132 //\r
2133 Unclear = TRUE;\r
2134 break;\r
2135 }\r
2136\r
2137 SensePtr++;\r
2138 }\r
2139\r
2140 return Unclear;\r
2141}\r
2142\r
2143/** \r
2144 Check if there is media error according to sense data.\r
2145\r
2146 @param[in] SenseData Pointer to sense data.\r
2147 @param[in] SenseCounts Count of sense data.\r
2148\r
2149 @retval TRUE Media error\r
2150 @retval FALSE No media error\r
2151\r
2152**/\r
2153BOOLEAN\r
2154IsMediaError (\r
2155 IN ATAPI_REQUEST_SENSE_DATA *SenseData,\r
2156 IN UINTN SenseCounts\r
2157 )\r
2158{\r
2159 ATAPI_REQUEST_SENSE_DATA *SensePtr;\r
2160 UINTN Index;\r
2161 BOOLEAN IsError;\r
2162\r
2163 IsError = FALSE;\r
2164\r
2165 SensePtr = SenseData;\r
2166\r
2167 for (Index = 0; Index < SenseCounts; Index++) {\r
2168\r
2169 switch (SensePtr->sense_key) {\r
2170\r
2171 case ATA_SK_MEDIUM_ERROR:\r
2172 switch (SensePtr->addnl_sense_code) {\r
2173 case ATA_ASC_MEDIA_ERR1:\r
2174 //\r
2175 // fall through\r
2176 //\r
2177 case ATA_ASC_MEDIA_ERR2:\r
2178 //\r
2179 // fall through\r
2180 //\r
2181 case ATA_ASC_MEDIA_ERR3:\r
2182 //\r
2183 // fall through\r
2184 //\r
2185 case ATA_ASC_MEDIA_ERR4:\r
2186 IsError = TRUE;\r
2187 break;\r
2188\r
2189 default:\r
2190 break;\r
2191 }\r
2192\r
2193 break;\r
2194\r
2195 case ATA_SK_NOT_READY:\r
2196 switch (SensePtr->addnl_sense_code) {\r
2197 case ATA_ASC_MEDIA_UPSIDE_DOWN:\r
2198 IsError = TRUE;\r
2199 break;\r
2200\r
2201 default:\r
2202 break;\r
2203 }\r
2204 break;\r
2205\r
2206 default:\r
2207 break;\r
2208 }\r
2209\r
2210 SensePtr++;\r
2211 }\r
2212\r
2213 return IsError;\r
2214}\r
2215\r
2216/** \r
2217 Check if drive is ready according to sense data.\r
2218\r
2219 @param[in] SenseData Pointer to sense data.\r
2220 @param[in] SenseCounts Count of sense data.\r
2221 @param[out] NeedRetry Indicate if retry is needed.\r
2222\r
2223 @retval TRUE Drive ready\r
2224 @retval FALSE Drive not ready\r
2225\r
2226**/\r
2227BOOLEAN\r
2228IsDriveReady (\r
2229 IN ATAPI_REQUEST_SENSE_DATA *SenseData,\r
2230 IN UINTN SenseCounts,\r
2231 OUT BOOLEAN *NeedRetry\r
2232 )\r
2233{\r
2234 ATAPI_REQUEST_SENSE_DATA *SensePtr;\r
2235 UINTN Index;\r
2236 BOOLEAN IsReady;\r
2237\r
2238 IsReady = TRUE;\r
2239 *NeedRetry = FALSE;\r
2240\r
2241 SensePtr = SenseData;\r
2242\r
2243 for (Index = 0; Index < SenseCounts; Index++) {\r
2244\r
2245 switch (SensePtr->sense_key) {\r
2246\r
2247 case ATA_SK_NOT_READY:\r
2248 switch (SensePtr->addnl_sense_code) {\r
2249 case ATA_ASC_NOT_READY:\r
2250 switch (SensePtr->addnl_sense_code_qualifier) {\r
2251 case ATA_ASCQ_IN_PROGRESS:\r
2252 IsReady = FALSE;\r
2253 *NeedRetry = TRUE;\r
2254 break;\r
2255\r
2256 default:\r
2257 IsReady = FALSE;\r
2258 *NeedRetry = FALSE;\r
2259 break;\r
2260 }\r
2261 break;\r
2262\r
2263 default:\r
2264 break;\r
2265 }\r
2266 break;\r
2267\r
2268 default:\r
2269 break;\r
2270 }\r
2271\r
2272 SensePtr++;\r
2273 }\r
2274\r
2275 return IsReady;\r
2276}\r
EFI Development Kit II mirror for PVE