Fix PeiLoadImage() for compressed peim to print the correct image address and entrypoint.
[mirror_edk2.git] / EdkModulePkg / Bus / Pci / AtapiPassThru / Dxe / AtapiPassThru.c
1 /** @file
2 Copyright (c) 2006, Intel Corporation
3 All rights reserved. This program and the accompanying materials
4 are licensed and made available under the terms and conditions of the BSD License
5 which accompanies this distribution. The full text of the license may be found at
6 http://opensource.org/licenses/bsd-license.php
7
8 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
9 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
10
11 **/
12
13 #include "AtapiPassThru.h"
14
15 EFI_STATUS
16 EFIAPI
17 AtapiScsiPassThruDriverBindingSupported (
18 IN EFI_DRIVER_BINDING_PROTOCOL *This,
19 IN EFI_HANDLE Controller,
20 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
21 );
22
23 EFI_STATUS
24 EFIAPI
25 AtapiScsiPassThruDriverBindingStart (
26 IN EFI_DRIVER_BINDING_PROTOCOL *This,
27 IN EFI_HANDLE Controller,
28 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
29 );
30
31 EFI_STATUS
32 EFIAPI
33 AtapiScsiPassThruDriverBindingStop (
34 IN EFI_DRIVER_BINDING_PROTOCOL *This,
35 IN EFI_HANDLE Controller,
36 IN UINTN NumberOfChildren,
37 IN EFI_HANDLE *ChildHandleBuffer
38 );
39
40 ///
41 /// IDE registers' fixed address
42 ///
43 static IDE_BASE_REGISTERS gAtapiIoPortRegisters[2] = {
44 { 0x1f0, { 0x1f1 }, 0x1f2, 0x1f3, 0x1f4, 0x1f5, 0x1f6, { 0x1f7 }, { 0x3f6 }, 0x3f7, 0 },
45 { 0x170, { 0x171 }, 0x172, 0x173, 0x174, 0x175, 0x176, { 0x177 }, { 0x376 }, 0x377, 0 }
46 };
47
48 static SCSI_COMMAND_SET gEndTable = { 0xff, 0xff };
49
50 ///
51 /// This table contains all the supported ATAPI commands.
52 ///
53 static SCSI_COMMAND_SET gSupportedATAPICommands[] = {
54 { OP_INQUIRY, DataIn },
55 { OP_LOAD_UNLOAD_CD, NoData },
56 { OP_MECHANISM_STATUS, DataIn },
57 { OP_MODE_SELECT_10, DataOut },
58 { OP_MODE_SENSE_10, DataIn },
59 { OP_PAUSE_RESUME, NoData },
60 { OP_PLAY_AUDIO_10, DataIn },
61 { OP_PLAY_AUDIO_MSF, DataIn },
62 { OP_PLAY_CD, DataIn },
63 { OP_PLAY_CD_MSF, DataIn },
64 { OP_PREVENT_ALLOW_MEDIUM_REMOVAL,NoData },
65 { OP_READ_10, DataIn },
66 { OP_READ_12, DataIn },
67 { OP_READ_CAPACITY, DataIn },
68 { OP_READ_CD, DataIn },
69 { OP_READ_CD_MSF, DataIn },
70 { OP_READ_HEADER, DataIn },
71 { OP_READ_SUB_CHANNEL, DataIn },
72 { OP_READ_TOC, DataIn },
73 { OP_REQUEST_SENSE, DataIn },
74 { OP_SCAN, NoData },
75 { OP_SEEK_10, NoData },
76 { OP_SET_CD_SPEED, DataOut },
77 { OP_STOPPLAY_SCAN, NoData },
78 { OP_START_STOP_UNIT, NoData },
79 { OP_TEST_UNIT_READY, NoData },
80 { OP_FORMAT_UNIT, DataOut },
81 { OP_READ_FORMAT_CAPACITIES, DataIn },
82 { OP_VERIFY, DataOut },
83 { OP_WRITE_10, DataOut },
84 { OP_WRITE_12, DataOut },
85 { OP_WRITE_AND_VERIFY, DataOut },
86 { 0xff, 0xff }
87 };
88
89 static CHAR16 *gControllerNameString = (CHAR16 *) L"ATAPI Controller";
90 static CHAR16 *gAtapiChannelString = (CHAR16 *) L"ATAPI Channel";
91
92 EFI_DRIVER_BINDING_PROTOCOL gAtapiScsiPassThruDriverBinding = {
93 AtapiScsiPassThruDriverBindingSupported,
94 AtapiScsiPassThruDriverBindingStart,
95 AtapiScsiPassThruDriverBindingStop,
96 0x10,
97 NULL,
98 NULL
99 };
100
101 /**
102 Supported.
103
104 (Standard DriverBinding Protocol Supported() function)
105
106 @return EFI_STATUS
107
108 @todo This - add argument and description to function comment
109 @todo Controller - add argument and description to function comment
110 @todo RemainingDevicePath - add argument and description to function comment
111 @todo EFI_UNSUPPORTED - add return value to function comment
112 **/
113 EFI_STATUS
114 EFIAPI
115 AtapiScsiPassThruDriverBindingSupported (
116 IN EFI_DRIVER_BINDING_PROTOCOL *This,
117 IN EFI_HANDLE Controller,
118 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
119 )
120 {
121 EFI_STATUS Status;
122 EFI_PCI_IO_PROTOCOL *PciIo;
123 PCI_TYPE00 Pci;
124
125 //
126 // Open the IO Abstraction(s) needed to perform the supported test
127 //
128 Status = gBS->OpenProtocol (
129 Controller,
130 &gEfiPciIoProtocolGuid,
131 (VOID **) &PciIo,
132 This->DriverBindingHandle,
133 Controller,
134 EFI_OPEN_PROTOCOL_BY_DRIVER
135 );
136 if (EFI_ERROR (Status)) {
137 return Status;
138 }
139 //
140 // Use the PCI I/O Protocol to see if Controller is a IDE Controller that
141 // can be managed by this driver. Read the PCI Configuration Header
142 // for this device.
143 //
144 Status = PciIo->Pci.Read (
145 PciIo,
146 EfiPciIoWidthUint32,
147 0,
148 sizeof (Pci) / sizeof (UINT32),
149 &Pci
150 );
151 if (EFI_ERROR (Status)) {
152 gBS->CloseProtocol (
153 Controller,
154 &gEfiPciIoProtocolGuid,
155 This->DriverBindingHandle,
156 Controller
157 );
158 return EFI_UNSUPPORTED;
159 }
160
161 if (Pci.Hdr.ClassCode[2] != PCI_CLASS_MASS_STORAGE || Pci.Hdr.ClassCode[1] != PCI_CLASS_IDE) {
162
163 Status = EFI_UNSUPPORTED;
164 }
165
166 gBS->CloseProtocol (
167 Controller,
168 &gEfiPciIoProtocolGuid,
169 This->DriverBindingHandle,
170 Controller
171 );
172
173 return Status;
174 }
175
176 /**
177 Create handles for IDE channels specified by RemainingDevicePath.
178 Install SCSI Pass Thru Protocol onto each created handle.
179
180 (Standard DriverBinding Protocol Start() function)
181
182 @return EFI_STATUS
183
184 @todo This - add argument and description to function comment
185 @todo Controller - add argument and description to function comment
186 @todo RemainingDevicePath - add argument and description to function comment
187 **/
188 EFI_STATUS
189 EFIAPI
190 AtapiScsiPassThruDriverBindingStart (
191 IN EFI_DRIVER_BINDING_PROTOCOL *This,
192 IN EFI_HANDLE Controller,
193 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
194 )
195 {
196 EFI_STATUS Status;
197 EFI_PCI_IO_PROTOCOL *PciIo;
198
199 PciIo = NULL;
200 Status = gBS->OpenProtocol (
201 Controller,
202 &gEfiPciIoProtocolGuid,
203 (VOID **) &PciIo,
204 This->DriverBindingHandle,
205 Controller,
206 EFI_OPEN_PROTOCOL_BY_DRIVER
207 );
208 if (EFI_ERROR (Status)) {
209 return Status;
210 }
211
212 Status = PciIo->Attributes (
213 PciIo,
214 EfiPciIoAttributeOperationEnable,
215 EFI_PCI_IO_ATTRIBUTE_IDE_PRIMARY_IO | EFI_PCI_IO_ATTRIBUTE_IDE_SECONDARY_IO | EFI_PCI_DEVICE_ENABLE,
216 NULL
217 );
218 if (EFI_ERROR (Status)) {
219 goto Done;
220 }
221
222 //
223 // Create SCSI Pass Thru instance for the IDE channel.
224 //
225 Status = RegisterAtapiScsiPassThru (This, Controller, PciIo);
226
227 Done:
228 if (EFI_ERROR (Status)) {
229 if (PciIo) {
230 PciIo->Attributes (
231 PciIo,
232 EfiPciIoAttributeOperationDisable,
233 EFI_PCI_IO_ATTRIBUTE_IDE_PRIMARY_IO | EFI_PCI_IO_ATTRIBUTE_IDE_SECONDARY_IO | EFI_PCI_DEVICE_ENABLE,
234 NULL
235 );
236 }
237
238 gBS->CloseProtocol (
239 Controller,
240 &gEfiPciIoProtocolGuid,
241 This->DriverBindingHandle,
242 Controller
243 );
244 }
245
246 return Status;
247 }
248
249 /**
250 Stop.
251
252 (Standard DriverBinding Protocol Stop() function)
253
254 @return EFI_STATUS
255
256 @todo This - add argument and description to function comment
257 @todo Controller - add argument and description to function comment
258 @todo NumberOfChildren - add argument and description to function comment
259 @todo ChildHandleBuffer - add argument and description to function comment
260 @todo EFI_SUCCESS - add return value to function comment
261 **/
262 EFI_STATUS
263 EFIAPI
264 AtapiScsiPassThruDriverBindingStop (
265 IN EFI_DRIVER_BINDING_PROTOCOL *This,
266 IN EFI_HANDLE Controller,
267 IN UINTN NumberOfChildren,
268 IN EFI_HANDLE *ChildHandleBuffer
269 )
270 {
271 EFI_STATUS Status;
272 EFI_SCSI_PASS_THRU_PROTOCOL *ScsiPassThru;
273 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate;
274
275 Status = gBS->OpenProtocol (
276 Controller,
277 &gEfiScsiPassThruProtocolGuid,
278 (VOID **) &ScsiPassThru,
279 This->DriverBindingHandle,
280 Controller,
281 EFI_OPEN_PROTOCOL_GET_PROTOCOL
282 );
283 if (EFI_ERROR (Status)) {
284 return Status;
285 }
286
287 AtapiScsiPrivate = ATAPI_SCSI_PASS_THRU_DEV_FROM_THIS (ScsiPassThru);
288
289 Status = gBS->UninstallProtocolInterface (
290 Controller,
291 &gEfiScsiPassThruProtocolGuid,
292 &AtapiScsiPrivate->ScsiPassThru
293 );
294 if (EFI_ERROR (Status)) {
295 return Status;
296 }
297 //
298 // Release Pci Io protocol on the controller handle.
299 //
300 AtapiScsiPrivate->PciIo->Attributes (
301 AtapiScsiPrivate->PciIo,
302 EfiPciIoAttributeOperationDisable,
303 EFI_PCI_IO_ATTRIBUTE_IDE_PRIMARY_IO | EFI_PCI_IO_ATTRIBUTE_IDE_SECONDARY_IO | EFI_PCI_DEVICE_ENABLE,
304 NULL
305 );
306
307 gBS->CloseProtocol (
308 Controller,
309 &gEfiPciIoProtocolGuid,
310 This->DriverBindingHandle,
311 Controller
312 );
313
314 gBS->FreePool (AtapiScsiPrivate);
315
316 return EFI_SUCCESS;
317 }
318
319 /**
320 Attaches SCSI Pass Thru Protocol for specified IDE channel.
321
322 @param Controller: Parent device handle to the IDE channel.
323 @param PciIo: PCI I/O protocol attached on the "Controller".
324
325 @return EFI_SUCCESS Always returned unless installing SCSI Pass Thru Protocol failed.
326
327 @todo This - add argument and description to function comment
328 @todo Controller - add argument and description to function comment
329 @todo PciIo - add argument and description to function comment
330 @todo EFI_OUT_OF_RESOURCES - add return value to function comment
331 **/
332 EFI_STATUS
333 RegisterAtapiScsiPassThru (
334 IN EFI_DRIVER_BINDING_PROTOCOL *This,
335 IN EFI_HANDLE Controller,
336 IN EFI_PCI_IO_PROTOCOL *PciIo
337 )
338 {
339 EFI_STATUS Status;
340 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate;
341 UINT64 Attributes;
342
343 AtapiScsiPrivate = AllocateZeroPool (sizeof (ATAPI_SCSI_PASS_THRU_DEV));
344 if (AtapiScsiPrivate == NULL) {
345 return EFI_OUT_OF_RESOURCES;
346 }
347
348 Attributes = EFI_PCI_IO_ATTRIBUTE_IDE_PRIMARY_IO | EFI_PCI_IO_ATTRIBUTE_IDE_SECONDARY_IO | EFI_PCI_DEVICE_ENABLE;
349 CopyMem (AtapiScsiPrivate->ChannelName, gAtapiChannelString, sizeof (gAtapiChannelString));
350
351 //
352 // Enable channel
353 //
354 PciIo->Attributes (PciIo, EfiPciIoAttributeOperationSet, Attributes, NULL);
355
356 AtapiScsiPrivate->Signature = ATAPI_SCSI_PASS_THRU_DEV_SIGNATURE;
357 AtapiScsiPrivate->Handle = Controller;
358
359 //
360 // will reset the IoPort inside each API function.
361 //
362 AtapiScsiPrivate->IoPort = gAtapiIoPortRegisters;
363 AtapiScsiPrivate->PciIo = PciIo;
364
365 //
366 // initialize SCSI Pass Thru Protocol interface
367 //
368 AtapiScsiPrivate->ScsiPassThru.Mode = &AtapiScsiPrivate->ScsiPassThruMode;
369 AtapiScsiPrivate->ScsiPassThru.PassThru = AtapiScsiPassThruFunction;
370 AtapiScsiPrivate->ScsiPassThru.GetNextDevice = AtapiScsiPassThruGetNextDevice;
371 AtapiScsiPrivate->ScsiPassThru.BuildDevicePath = AtapiScsiPassThruBuildDevicePath;
372 AtapiScsiPrivate->ScsiPassThru.GetTargetLun = AtapiScsiPassThruGetTargetLun;
373 AtapiScsiPrivate->ScsiPassThru.ResetChannel = AtapiScsiPassThruResetChannel;
374 AtapiScsiPrivate->ScsiPassThru.ResetTarget = AtapiScsiPassThruResetTarget;
375
376 //
377 // Set Mode
378 //
379 CopyMem (AtapiScsiPrivate->ControllerName, gControllerNameString, sizeof (gControllerNameString));
380
381 AtapiScsiPrivate->ScsiPassThruMode.ControllerName = AtapiScsiPrivate->ControllerName;
382 AtapiScsiPrivate->ScsiPassThruMode.ChannelName = AtapiScsiPrivate->ChannelName;
383 AtapiScsiPrivate->ScsiPassThruMode.AdapterId = 4;
384 //
385 // non-RAID SCSI controllers should set both physical and logical attributes
386 //
387 AtapiScsiPrivate->ScsiPassThruMode.Attributes = EFI_SCSI_PASS_THRU_ATTRIBUTES_PHYSICAL |
388 EFI_SCSI_PASS_THRU_ATTRIBUTES_LOGICAL;
389 AtapiScsiPrivate->ScsiPassThruMode.IoAlign = 0;
390
391 //
392 // Initialize the LatestTargetId to 0xFFFFFFFF (for the GetNextDevice() call).
393 //
394 AtapiScsiPrivate->LatestTargetId = 0xFFFFFFFF;
395 AtapiScsiPrivate->LatestLun = 0;
396
397 Status = gBS->InstallProtocolInterface (
398 &Controller,
399 &gEfiScsiPassThruProtocolGuid,
400 EFI_NATIVE_INTERFACE,
401 &AtapiScsiPrivate->ScsiPassThru
402 );
403 return Status;
404 }
405
406 /**
407 Implements EFI_SCSI_PASS_THRU_PROTOCOL.PassThru() function.
408
409 @param This The EFI_SCSI_PASS_THRU_PROTOCOL instance.
410 @param Target The Target ID of the ATAPI device to send the SCSI
411 Request Packet. To ATAPI devices attached on an IDE
412 Channel, Target ID 0 indicates Master device;Target
413 ID 1 indicates Slave device.
414 @param Lun The LUN of the ATAPI device to send the SCSI Request
415 Packet. To the ATAPI device, Lun is always 0.
416 @param Packet The SCSI Request Packet to send to the ATAPI device
417 specified by Target and Lun.
418 @param Event If non-blocking I/O is not supported then Event is ignored,
419 and blocking I/O is performed.<br>
420 If Event is NULL, then blocking I/O is performed.<br>
421 If Event is not NULL and non blocking I/O is supported,
422 then non-blocking I/O is performed, and Event will be signaled
423 when the SCSI Request Packet completes.
424
425 @todo This - add argument and description to function comment
426 @todo EFI_INVALID_PARAMETER - add return value to function comment
427 @todo EFI_SUCCESS - add return value to function comment
428 **/
429 EFI_STATUS
430 EFIAPI
431 AtapiScsiPassThruFunction (
432 IN EFI_SCSI_PASS_THRU_PROTOCOL *This,
433 IN UINT32 Target,
434 IN UINT64 Lun,
435 IN OUT EFI_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet,
436 IN EFI_EVENT Event OPTIONAL
437 )
438 {
439 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate;
440 EFI_STATUS Status;
441
442 AtapiScsiPrivate = ATAPI_SCSI_PASS_THRU_DEV_FROM_THIS (This);
443
444 //
445 // Target is not allowed beyond MAX_TARGET_ID
446 //
447 if (Target > MAX_TARGET_ID) {
448 return EFI_INVALID_PARAMETER;
449 }
450
451 //
452 // check the data fields in Packet parameter.
453 //
454 Status = CheckSCSIRequestPacket (Packet);
455 if (EFI_ERROR (Status)) {
456 return Status;
457 }
458
459 //
460 // If Request Packet targets at the IDE channel itself,
461 // do nothing.
462 //
463 if (Target == This->Mode->AdapterId) {
464 Packet->TransferLength = 0;
465 return EFI_SUCCESS;
466 }
467
468 //
469 // According to Target ID, reset the Atapi I/O Register mapping
470 // (Target Id in [0,1] area, using gAtapiIoPortRegisters[0],
471 // Target Id in [2,3] area, using gAtapiIoPortRegisters[1]
472 //
473 if ((Target / 2) == 0) {
474 AtapiScsiPrivate->IoPort = &gAtapiIoPortRegisters[0];
475 } else {
476 AtapiScsiPrivate->IoPort = &gAtapiIoPortRegisters[1];
477 }
478
479 //
480 // the ATAPI SCSI interface does not support non-blocking I/O
481 // ignore the Event parameter
482 //
483 // Performs blocking I/O.
484 //
485 Status = SubmitBlockingIoCommand (AtapiScsiPrivate, Target, Packet);
486 return Status;
487 }
488
489 /**
490 Used to retrieve the list of legal Target IDs for SCSI devices
491 on a SCSI channel.
492
493 @param This Protocol instance pointer.
494 @param Target On input, a pointer to the Target ID of a SCSI
495 device present on the SCSI channel. On output,
496 a pointer to the Target ID of the next SCSI device
497 present on a SCSI channel. An input value of
498 0xFFFFFFFF retrieves the Target ID of the first
499 SCSI device present on a SCSI channel.
500 @param Lun On input, a pointer to the LUN of a SCSI device
501 present on the SCSI channel. On output, a pointer
502 to the LUN of the next SCSI device present on
503 a SCSI channel.
504
505 @retval EFI_SUCCESS The Target ID and Lun of the next SCSI device
506 on the SCSI channel was returned in Target and Lun.
507 @retval EFI_NOT_FOUND There are no more SCSI devices on this SCSI channel.
508 @retval EFI_INVALID_PARAMETER Target is not 0xFFFFFFFF,and Target and Lun were not
509 returned on a previous call to GetNextDevice().
510
511 **/
512 EFI_STATUS
513 EFIAPI
514 AtapiScsiPassThruGetNextDevice (
515 IN EFI_SCSI_PASS_THRU_PROTOCOL *This,
516 IN OUT UINT32 *Target,
517 IN OUT UINT64 *Lun
518 )
519 {
520 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate;
521
522 //
523 // Retrieve Device Private Data Structure.
524 //
525 AtapiScsiPrivate = ATAPI_SCSI_PASS_THRU_DEV_FROM_THIS (This);
526
527 //
528 // Check whether Target is valid.
529 //
530 if (Target == NULL || Lun == NULL) {
531 return EFI_INVALID_PARAMETER;
532 }
533
534 if ((*Target != 0xFFFFFFFF) &&
535 ((*Target != AtapiScsiPrivate->LatestTargetId) ||
536 (*Lun != AtapiScsiPrivate->LatestLun))) {
537 return EFI_INVALID_PARAMETER;
538 }
539
540 if (*Target == MAX_TARGET_ID) {
541 return EFI_NOT_FOUND;
542 }
543
544 if (*Target == 0xFFFFFFFF) {
545 *Target = 0;
546 } else {
547 *Target = AtapiScsiPrivate->LatestTargetId + 1;
548 }
549
550 *Lun = 0;
551
552 //
553 // Update the LatestTargetId.
554 //
555 AtapiScsiPrivate->LatestTargetId = *Target;
556 AtapiScsiPrivate->LatestLun = *Lun;
557
558 return EFI_SUCCESS;
559
560 }
561
562 /**
563 Used to allocate and build a device path node for a SCSI device
564 on a SCSI channel. Would not build device path for a SCSI Host Controller.
565
566 @param This Protocol instance pointer.
567 @param Target The Target ID of the SCSI device for which
568 a device path node is to be allocated and built.
569 @param Lun The LUN of the SCSI device for which a device
570 path node is to be allocated and built.
571 @param DevicePath A pointer to a single device path node that
572 describes the SCSI device specified by
573 Target and Lun. This function is responsible
574 for allocating the buffer DevicePath with the boot
575 service AllocatePool(). It is the caller's
576 responsibility to free DevicePath when the caller
577 is finished with DevicePath.
578
579 @retval EFI_SUCCESS The device path node that describes the SCSI device
580 specified by Target and Lun was allocated and
581 returned in DevicePath.
582 @retval EFI_NOT_FOUND The SCSI devices specified by Target and Lun does
583 not exist on the SCSI channel.
584 @retval EFI_INVALID_PARAMETER DevicePath is NULL.
585 @retval EFI_OUT_OF_RESOURCES There are not enough resources to allocate
586 DevicePath.
587
588 **/
589 EFI_STATUS
590 EFIAPI
591 AtapiScsiPassThruBuildDevicePath (
592 IN EFI_SCSI_PASS_THRU_PROTOCOL *This,
593 IN UINT32 Target,
594 IN UINT64 Lun,
595 IN OUT EFI_DEVICE_PATH_PROTOCOL **DevicePath
596 )
597 {
598 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate;
599 EFI_DEV_PATH *Node;
600
601 //
602 // Retrieve Device Private Data Structure.
603 //
604 AtapiScsiPrivate = ATAPI_SCSI_PASS_THRU_DEV_FROM_THIS (This);
605
606 //
607 // Validate parameters passed in.
608 //
609
610 if (DevicePath == NULL) {
611 return EFI_INVALID_PARAMETER;
612 }
613
614 //
615 // can not build device path for the SCSI Host Controller.
616 //
617 if ((Target > (MAX_TARGET_ID - 1)) || (Lun != 0)) {
618 return EFI_NOT_FOUND;
619 }
620
621 Node = AllocateZeroPool (sizeof (EFI_DEV_PATH));
622 if (Node == NULL) {
623 return EFI_OUT_OF_RESOURCES;
624 }
625
626 Node->DevPath.Type = MESSAGING_DEVICE_PATH;
627 Node->DevPath.SubType = MSG_ATAPI_DP;
628 SetDevicePathNodeLength (&Node->DevPath, sizeof (ATAPI_DEVICE_PATH));
629
630 Node->Atapi.PrimarySecondary = (UINT8) (Target / 2);
631 Node->Atapi.SlaveMaster = (UINT8) (Target % 2);
632 Node->Atapi.Lun = (UINT16) Lun;
633
634 *DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) Node;
635
636 return EFI_SUCCESS;
637 }
638
639 /**
640 Used to translate a device path node to a Target ID and LUN.
641
642 @param This Protocol instance pointer.
643 @param DevicePath A pointer to the device path node that
644 describes a SCSI device on the SCSI channel.
645 @param Target A pointer to the Target ID of a SCSI device
646 on the SCSI channel.
647 @param Lun A pointer to the LUN of a SCSI device on
648 the SCSI channel.
649
650 @retval EFI_SUCCESS DevicePath was successfully translated to a
651 Target ID and LUN, and they were returned
652 in Target and Lun.
653 @retval EFI_INVALID_PARAMETER DevicePath is NULL.
654 @retval EFI_INVALID_PARAMETER Target is NULL.
655 @retval EFI_INVALID_PARAMETER Lun is NULL.
656 @retval EFI_UNSUPPORTED This driver does not support the device path
657 node type in DevicePath.
658 @retval EFI_NOT_FOUND A valid translation from DevicePath to a
659 Target ID and LUN does not exist.
660
661 **/
662 EFI_STATUS
663 EFIAPI
664 AtapiScsiPassThruGetTargetLun (
665 IN EFI_SCSI_PASS_THRU_PROTOCOL *This,
666 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
667 OUT UINT32 *Target,
668 OUT UINT64 *Lun
669 )
670 {
671 EFI_DEV_PATH *Node;
672
673 //
674 // Validate parameters passed in.
675 //
676 if (DevicePath == NULL || Target == NULL || Lun == NULL) {
677 return EFI_INVALID_PARAMETER;
678 }
679
680 //
681 // Check whether the DevicePath belongs to SCSI_DEVICE_PATH
682 //
683 if ((DevicePath->Type != MESSAGING_DEVICE_PATH) ||
684 (DevicePath->SubType != MSG_ATAPI_DP) ||
685 (DevicePathNodeLength(DevicePath) != sizeof(ATAPI_DEVICE_PATH))) {
686 return EFI_UNSUPPORTED;
687 }
688
689 Node = (EFI_DEV_PATH *) DevicePath;
690
691 *Target = Node->Atapi.PrimarySecondary * 2 + Node->Atapi.SlaveMaster;
692 *Lun = Node->Atapi.Lun;
693
694 if (*Target > (MAX_TARGET_ID - 1) || *Lun != 0) {
695 return EFI_NOT_FOUND;
696 }
697
698 return EFI_SUCCESS;
699 }
700
701 /**
702 Resets a SCSI channel.This operation resets all the
703 SCSI devices connected to the SCSI channel.
704
705 @param This Protocol instance pointer.
706
707 @retval EFI_SUCCESS The SCSI channel was reset.
708 @retval EFI_UNSUPPORTED The SCSI channel does not support
709 a channel reset operation.
710 @retval EFI_DEVICE_ERROR A device error occurred while
711 attempting to reset the SCSI channel.
712 @retval EFI_TIMEOUT A timeout occurred while attempting
713 to reset the SCSI channel.
714
715 **/
716 EFI_STATUS
717 EFIAPI
718 AtapiScsiPassThruResetChannel (
719 IN EFI_SCSI_PASS_THRU_PROTOCOL *This
720 )
721 {
722 UINT8 DeviceControlValue;
723 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate;
724 UINT8 Index;
725
726 AtapiScsiPrivate = ATAPI_SCSI_PASS_THRU_DEV_FROM_THIS (This);
727
728 //
729 // Reset both Primary channel and Secondary channel.
730 // so, the IoPort pointer must point to the right I/O Register group
731 //
732 for (Index = 0; Index < 2; Index++) {
733 //
734 // Reset
735 //
736 AtapiScsiPrivate->IoPort = &gAtapiIoPortRegisters[Index];
737
738 DeviceControlValue = 0;
739 //
740 // set SRST bit to initiate soft reset
741 //
742 DeviceControlValue |= SRST;
743 //
744 // disable Interrupt
745 //
746 DeviceControlValue |= bit (1);
747 WritePortB (
748 AtapiScsiPrivate->PciIo,
749 AtapiScsiPrivate->IoPort->Alt.DeviceControl,
750 DeviceControlValue
751 );
752
753 //
754 // Wait 10us
755 //
756 gBS->Stall (10);
757
758 //
759 // Clear SRST bit
760 // 0xfb:1111,1011
761 //
762 DeviceControlValue &= 0xfb;
763
764 WritePortB (AtapiScsiPrivate->PciIo, AtapiScsiPrivate->IoPort->Alt.DeviceControl, DeviceControlValue);
765
766 //
767 // slave device needs at most 31s to clear BSY
768 //
769 if (StatusWaitForBSYClear (AtapiScsiPrivate, 31000) == EFI_TIMEOUT) {
770 return EFI_DEVICE_ERROR;
771 }
772 }
773
774 return EFI_SUCCESS;
775 }
776
777 /**
778 Resets a SCSI device that is connected to a SCSI channel.
779
780 @param This Protocol instance pointer.
781 @param Target The Target ID of the SCSI device to reset.
782 @param Lun The LUN of the SCSI device to reset.
783
784 @retval EFI_SUCCESS The SCSI device specified by Target and
785 Lun was reset.
786 @retval EFI_UNSUPPORTED The SCSI channel does not support a target
787 reset operation.
788 @retval EFI_INVALID_PARAMETER Target or Lun are invalid.
789 @retval EFI_DEVICE_ERROR A device error occurred while attempting
790 to reset the SCSI device specified by Target
791 and Lun.
792 @retval EFI_TIMEOUT A timeout occurred while attempting to reset
793 the SCSI device specified by Target and Lun.
794
795 **/
796 EFI_STATUS
797 EFIAPI
798 AtapiScsiPassThruResetTarget (
799 IN EFI_SCSI_PASS_THRU_PROTOCOL *This,
800 IN UINT32 Target,
801 IN UINT64 Lun
802 )
803 {
804 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate;
805 UINT8 Command;
806 UINT8 DeviceSelect;
807
808 AtapiScsiPrivate = ATAPI_SCSI_PASS_THRU_DEV_FROM_THIS (This);
809
810 if (Target > MAX_TARGET_ID) {
811 return EFI_INVALID_PARAMETER;
812 }
813 //
814 // Directly return EFI_SUCCESS if want to reset the host controller
815 //
816 if (Target == This->Mode->AdapterId) {
817 return EFI_SUCCESS;
818 }
819
820 //
821 // According to Target ID, reset the Atapi I/O Register mapping
822 // (Target Id in [0,1] area, using gAtapiIoPortRegisters[0],
823 // Target Id in [2,3] area, using gAtapiIoPortRegisters[1]
824 //
825 if ((Target / 2) == 0) {
826 AtapiScsiPrivate->IoPort = &gAtapiIoPortRegisters[0];
827 } else {
828 AtapiScsiPrivate->IoPort = &gAtapiIoPortRegisters[1];
829 }
830
831 //
832 // for ATAPI device, no need to wait DRDY ready after device selecting.
833 //
834 // bit7 and bit5 are both set to 1 for backward compatibility
835 //
836 DeviceSelect = (UINT8) (((bit (7) | bit (5)) | (Target << 4)));
837 WritePortB (AtapiScsiPrivate->PciIo, AtapiScsiPrivate->IoPort->Head, DeviceSelect);
838
839 Command = ATAPI_SOFT_RESET_CMD;
840 WritePortB (AtapiScsiPrivate->PciIo, AtapiScsiPrivate->IoPort->Reg.Command, Command);
841
842 //
843 // BSY clear is the only status return to the host by the device
844 // when reset is complete.
845 // slave device needs at most 31s to clear BSY
846 //
847 if (EFI_ERROR (StatusWaitForBSYClear (AtapiScsiPrivate, 31000))) {
848 return EFI_DEVICE_ERROR;
849 }
850
851 //
852 // stall 5 seconds to make the device status stable
853 //
854 gBS->Stall (5000000);
855
856 return EFI_SUCCESS;
857 }
858
859
860 /**
861 Checks the parameters in the SCSI Request Packet to make sure
862 they are valid for a SCSI Pass Thru request.
863
864 @todo function comment is missing 'Routine Description:'
865 @todo function comment is missing 'Arguments:'
866 @todo function comment is missing 'Returns:'
867 @todo Packet - add argument and description to function comment
868 @todo EFI_INVALID_PARAMETER - add return value to function comment
869 @todo EFI_INVALID_PARAMETER - add return value to function comment
870 @todo EFI_INVALID_PARAMETER - add return value to function comment
871 @todo EFI_UNSUPPORTED - add return value to function comment
872 @todo EFI_SUCCESS - add return value to function comment
873 **/
874 EFI_STATUS
875 CheckSCSIRequestPacket (
876 EFI_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet
877 )
878 {
879 if (Packet == NULL) {
880 return EFI_INVALID_PARAMETER;
881 }
882
883 if (!ValidCdbLength (Packet->CdbLength)) {
884 return EFI_INVALID_PARAMETER;
885 }
886
887 if (Packet->Cdb == NULL) {
888 return EFI_INVALID_PARAMETER;
889 }
890
891 //
892 // Checks whether the request command is supported.
893 //
894 if (!IsCommandValid (Packet)) {
895 return EFI_UNSUPPORTED;
896 }
897
898 return EFI_SUCCESS;
899 }
900
901 /**
902 Checks the requested SCSI command:
903 Is it supported by this driver?
904 Is the Data transfer direction reasonable?
905
906 @todo function comment is missing 'Routine Description:'
907 @todo function comment is missing 'Arguments:'
908 @todo function comment is missing 'Returns:'
909 @todo Packet - add argument and description to function comment
910 **/
911 BOOLEAN
912 IsCommandValid (
913 EFI_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet
914 )
915 {
916 UINT8 Index;
917 UINT8 *OpCode;
918
919 OpCode = (UINT8 *) (Packet->Cdb);
920
921 for (Index = 0; CompareMem (&gSupportedATAPICommands[Index], &gEndTable, sizeof (SCSI_COMMAND_SET)); Index++) {
922
923 if (*OpCode == gSupportedATAPICommands[Index].OpCode) {
924 //
925 // Check whether the requested Command is supported by this driver
926 //
927 if (Packet->DataDirection == DataIn) {
928 //
929 // Check whether the requested data direction conforms to
930 // what it should be.
931 //
932 if (gSupportedATAPICommands[Index].Direction == DataOut) {
933 return FALSE;
934 }
935 }
936
937 if (Packet->DataDirection == DataOut) {
938 //
939 // Check whether the requested data direction conforms to
940 // what it should be.
941 //
942 if (gSupportedATAPICommands[Index].Direction == DataIn) {
943 return FALSE;
944 }
945 }
946
947 return TRUE;
948 }
949 }
950
951 return FALSE;
952 }
953
954 /**
955 Performs blocking I/O request.
956
957 @param AtapiScsiPrivate Private data structure for the specified channel.
958 @param Target The Target ID of the ATAPI device to send the SCSI
959 Request Packet. To ATAPI devices attached on an IDE
960 Channel, Target ID 0 indicates Master device;Target
961 ID 1 indicates Slave device.
962 @param Packet The SCSI Request Packet to send to the ATAPI device
963 specified by Target.
964
965 @todo AtapiScsiPrivate - add argument and description to function comment
966 **/
967 EFI_STATUS
968 SubmitBlockingIoCommand (
969 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
970 UINT32 Target,
971 EFI_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet
972 )
973 {
974 UINT8 PacketCommand[12];
975 UINT64 TimeoutInMicroSeconds;
976 EFI_STATUS PacketCommandStatus;
977
978 //
979 // Fill ATAPI Command Packet according to CDB
980 //
981 ZeroMem (&PacketCommand, 12);
982 CopyMem (&PacketCommand, Packet->Cdb, Packet->CdbLength);
983
984 //
985 // Timeout is 100ns unit, convert it to 1000ns (1us) unit.
986 //
987 TimeoutInMicroSeconds = DivU64x32 (Packet->Timeout, (UINT32) 10);
988
989 //
990 // Submit ATAPI Command Packet
991 //
992 PacketCommandStatus = AtapiPacketCommand (
993 AtapiScsiPrivate,
994 Target,
995 PacketCommand,
996 Packet->DataBuffer,
997 &(Packet->TransferLength),
998 Packet->DataDirection,
999 TimeoutInMicroSeconds
1000 );
1001 if (!EFI_ERROR (PacketCommandStatus) || (Packet->SenseData == NULL)) {
1002 Packet->SenseDataLength = 0;
1003 return PacketCommandStatus;
1004 }
1005 //
1006 // Return SenseData if PacketCommandStatus matches
1007 // the following return codes.
1008 //
1009 if ((PacketCommandStatus == EFI_WARN_BUFFER_TOO_SMALL) ||
1010 (PacketCommandStatus == EFI_DEVICE_ERROR) ||
1011 (PacketCommandStatus == EFI_TIMEOUT)) {
1012
1013 //
1014 // avoid submit request sense command continuously.
1015 //
1016 if (PacketCommand[0] == OP_REQUEST_SENSE) {
1017 Packet->SenseDataLength = 0;
1018 return PacketCommandStatus;
1019 }
1020
1021 RequestSenseCommand (
1022 AtapiScsiPrivate,
1023 Target,
1024 Packet->Timeout,
1025 Packet->SenseData,
1026 &Packet->SenseDataLength
1027 );
1028 }
1029
1030 return PacketCommandStatus;
1031 }
1032
1033 /**
1034 RequestSenseCommand
1035
1036 @param AtapiScsiPrivate
1037 @param Target
1038 @param Timeout
1039 @param SenseData
1040 @param SenseDataLength
1041
1042 @todo Add function description
1043 @todo AtapiScsiPrivate TODO: add argument description
1044 @todo Target TODO: add argument description
1045 @todo Timeout TODO: add argument description
1046 @todo SenseData TODO: add argument description
1047 @todo SenseDataLength TODO: add argument description
1048 @todo add return values
1049 **/
1050 EFI_STATUS
1051 RequestSenseCommand (
1052 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
1053 UINT32 Target,
1054 UINT64 Timeout,
1055 VOID *SenseData,
1056 UINT8 *SenseDataLength
1057 )
1058 {
1059 EFI_SCSI_PASS_THRU_SCSI_REQUEST_PACKET Packet;
1060 UINT8 Cdb[12];
1061 EFI_STATUS Status;
1062
1063 ZeroMem (&Packet, sizeof (EFI_SCSI_PASS_THRU_SCSI_REQUEST_PACKET));
1064 ZeroMem (Cdb, 12);
1065
1066 Cdb[0] = OP_REQUEST_SENSE;
1067 Cdb[4] = (UINT8) (*SenseDataLength);
1068
1069 Packet.Timeout = Timeout;
1070 Packet.DataBuffer = SenseData;
1071 Packet.SenseData = NULL;
1072 Packet.Cdb = Cdb;
1073 Packet.TransferLength = *SenseDataLength;
1074 Packet.CdbLength = 12;
1075 Packet.DataDirection = DataIn;
1076
1077 Status = SubmitBlockingIoCommand (AtapiScsiPrivate, Target, &Packet);
1078 *SenseDataLength = (UINT8) (Packet.TransferLength);
1079 return Status;
1080 }
1081
1082 /**
1083 Submits ATAPI command packet to the specified ATAPI device.
1084
1085 @param AtapiScsiPrivate: Private data structure for the specified channel.
1086 @param Target: The Target ID of the ATAPI device to send the SCSI
1087 Request Packet. To ATAPI devices attached on an IDE
1088 Channel, Target ID 0 indicates Master device;Target
1089 ID 1 indicates Slave device.
1090 @param PacketCommand: Points to the ATAPI command packet.
1091 @param Buffer: Points to the transferred data.
1092 @param ByteCount: When input,indicates the buffer size; when output,
1093 indicates the actually transferred data size.
1094 @param Direction: Indicates the data transfer direction.
1095 @param TimeoutInMicroSeconds: The timeout, in micro second units,
1096 to use for the execution of this ATAPI command.
1097 A TimeoutInMicroSeconds value of 0 means that
1098 this function will wait indefinitely for the ATAPI
1099 command to execute.
1100 <P>
1101 If TimeoutInMicroSeconds is greater than zero, then
1102 this function will return EFI_TIMEOUT if the time
1103 required to execute the ATAPI command is greater
1104 than TimeoutInMicroSeconds.
1105 </P>
1106
1107 @todo AtapiScsiPrivate - add argument and description to function comment
1108 @todo PacketCommand - add argument and description to function comment
1109 @todo Buffer - add argument and description to function comment
1110 @todo ByteCount - add argument and description to function comment
1111 @todo Direction - add argument and description to function comment
1112 **/
1113 EFI_STATUS
1114 AtapiPacketCommand (
1115 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
1116 UINT32 Target,
1117 UINT8 *PacketCommand,
1118 VOID *Buffer,
1119 UINT32 *ByteCount,
1120 DATA_DIRECTION Direction,
1121 UINT64 TimeoutInMicroSeconds
1122 )
1123 {
1124
1125 UINT16 *CommandIndex;
1126 UINT8 Count;
1127 EFI_STATUS Status;
1128
1129 //
1130 // Set all the command parameters by fill related registers.
1131 // Before write to all the following registers, BSY and DRQ must be 0.
1132 //
1133 Status = StatusDRQClear (AtapiScsiPrivate, TimeoutInMicroSeconds);
1134 if (EFI_ERROR (Status)) {
1135 if (Status == EFI_ABORTED) {
1136 Status = EFI_DEVICE_ERROR;
1137 }
1138
1139 *ByteCount = 0;
1140 return Status;
1141 }
1142 //
1143 // Select device via Device/Head Register.
1144 // "Target = 0" indicates device 0; "Target = 1" indicates device 1
1145 //
1146 WritePortB (
1147 AtapiScsiPrivate->PciIo,
1148 AtapiScsiPrivate->IoPort->Head,
1149 (UINT8) ((Target << 4) | DEFAULT_CMD) // DEFAULT_CMD: 0xa0 (1010,0000)
1150 );
1151
1152 //
1153 // No OVL; No DMA (by setting feature register)
1154 //
1155 WritePortB (
1156 AtapiScsiPrivate->PciIo,
1157 AtapiScsiPrivate->IoPort->Reg1.Feature,
1158 0x00
1159 );
1160
1161 //
1162 // set the transfersize to MAX_ATAPI_BYTE_COUNT to let the device
1163 // determine how much data should be transfered.
1164 //
1165 WritePortB (
1166 AtapiScsiPrivate->PciIo,
1167 AtapiScsiPrivate->IoPort->CylinderLsb,
1168 (UINT8) (MAX_ATAPI_BYTE_COUNT & 0x00ff)
1169 );
1170 WritePortB (
1171 AtapiScsiPrivate->PciIo,
1172 AtapiScsiPrivate->IoPort->CylinderMsb,
1173 (UINT8) (MAX_ATAPI_BYTE_COUNT >> 8)
1174 );
1175
1176 //
1177 // DEFAULT_CTL:0x0a (0000,1010)
1178 // Disable interrupt
1179 //
1180 WritePortB (
1181 AtapiScsiPrivate->PciIo,
1182 AtapiScsiPrivate->IoPort->Alt.DeviceControl,
1183 DEFAULT_CTL
1184 );
1185
1186 //
1187 // Send Packet command to inform device
1188 // that the following data bytes are command packet.
1189 //
1190 WritePortB (
1191 AtapiScsiPrivate->PciIo,
1192 AtapiScsiPrivate->IoPort->Reg.Command,
1193 PACKET_CMD
1194 );
1195
1196 //
1197 // Before data transfer, BSY should be 0 and DRQ should be 1.
1198 // if they are not in specified time frame,
1199 // retrieve Sense Key from Error Register before return.
1200 //
1201 Status = StatusDRQReady (AtapiScsiPrivate, TimeoutInMicroSeconds);
1202 if (EFI_ERROR (Status)) {
1203 if (Status == EFI_ABORTED) {
1204 Status = EFI_DEVICE_ERROR;
1205 }
1206
1207 *ByteCount = 0;
1208 return Status;
1209 }
1210
1211 //
1212 // Send out command packet
1213 //
1214 CommandIndex = (UINT16 *) PacketCommand;
1215 for (Count = 0; Count < 6; Count++, CommandIndex++) {
1216 WritePortW (AtapiScsiPrivate->PciIo, AtapiScsiPrivate->IoPort->Data, *CommandIndex);
1217 }
1218
1219 //
1220 // call AtapiPassThruPioReadWriteData() function to get
1221 // requested transfer data form device.
1222 //
1223 return AtapiPassThruPioReadWriteData (
1224 AtapiScsiPrivate,
1225 Buffer,
1226 ByteCount,
1227 Direction,
1228 TimeoutInMicroSeconds
1229 );
1230 }
1231
1232 /**
1233 Performs data transfer between ATAPI device and host after the
1234 ATAPI command packet is sent.
1235
1236 @param AtapiScsiPrivate: Private data structure for the specified channel.
1237 @param Buffer: Points to the transferred data.
1238 @param ByteCount: When input,indicates the buffer size; when output,
1239 indicates the actually transferred data size.
1240 @param Direction: Indicates the data transfer direction.
1241 @param TimeoutInMicroSeconds: The timeout, in micro second units,
1242 to use for the execution of this ATAPI command.
1243 A TimeoutInMicroSeconds value of 0 means that
1244 this function will wait indefinitely for the ATAPI
1245 command to execute.
1246 <P>
1247 If TimeoutInMicroSeconds is greater than zero, then
1248 this function will return EFI_TIMEOUT if the time
1249 required to execute the ATAPI command is greater
1250 than TimeoutInMicroSeconds.
1251 </P>
1252
1253 @todo AtapiScsiPrivate - add argument and description to function comment
1254 @todo Buffer - add argument and description to function comment
1255 @todo ByteCount - add argument and description to function comment
1256 @todo Direction - add argument and description to function comment
1257 @todo EFI_DEVICE_ERROR - add return value to function comment
1258 @todo EFI_DEVICE_ERROR - add return value to function comment
1259 @todo EFI_WARN_BUFFER_TOO_SMALL - add return value to function comment
1260 **/
1261 EFI_STATUS
1262 AtapiPassThruPioReadWriteData (
1263 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
1264 UINT16 *Buffer,
1265 UINT32 *ByteCount,
1266 DATA_DIRECTION Direction,
1267 UINT64 TimeoutInMicroSeconds
1268 )
1269 {
1270 UINT32 Index;
1271 UINT32 RequiredWordCount;
1272 UINT32 ActualWordCount;
1273
1274 UINT32 WordCount;
1275 EFI_STATUS Status;
1276 UINT16 *ptrBuffer;
1277
1278 Status = EFI_SUCCESS;
1279
1280 //
1281 // Non Data transfer request is also supported.
1282 //
1283 if (*ByteCount == 0 || Buffer == NULL) {
1284 *ByteCount = 0;
1285 if (EFI_ERROR (StatusWaitForBSYClear (AtapiScsiPrivate, TimeoutInMicroSeconds))) {
1286 return EFI_DEVICE_ERROR;
1287 }
1288 }
1289
1290 ptrBuffer = Buffer;
1291 RequiredWordCount = *ByteCount / 2;
1292
1293 //
1294 // ActuralWordCount means the word count of data really transfered.
1295 //
1296 ActualWordCount = 0;
1297
1298 while (ActualWordCount < RequiredWordCount) {
1299 //
1300 // before each data transfer stream, the host should poll DRQ bit ready,
1301 // which indicates device's ready for data transfer .
1302 //
1303 Status = StatusDRQReady (AtapiScsiPrivate, TimeoutInMicroSeconds);
1304 if (EFI_ERROR (Status)) {
1305 *ByteCount = ActualWordCount * 2;
1306
1307 AtapiPassThruCheckErrorStatus (AtapiScsiPrivate);
1308
1309 if (ActualWordCount == 0) {
1310 return EFI_DEVICE_ERROR;
1311 }
1312 //
1313 // ActualWordCount > 0
1314 //
1315 if (ActualWordCount < RequiredWordCount) {
1316 return EFI_WARN_BUFFER_TOO_SMALL;
1317 }
1318 }
1319 //
1320 // get current data transfer size from Cylinder Registers.
1321 //
1322 WordCount =
1323 (
1324 (ReadPortB (AtapiScsiPrivate->PciIo, AtapiScsiPrivate->IoPort->CylinderMsb) << 8) |
1325 ReadPortB (AtapiScsiPrivate->PciIo, AtapiScsiPrivate->IoPort->CylinderLsb)
1326 ) & 0xffff;
1327 WordCount /= 2;
1328
1329 //
1330 // perform a series data In/Out.
1331 //
1332 for (Index = 0; (Index < WordCount) && (ActualWordCount < RequiredWordCount); Index++, ActualWordCount++) {
1333
1334 if (Direction == DataIn) {
1335
1336 *ptrBuffer = ReadPortW (AtapiScsiPrivate->PciIo, AtapiScsiPrivate->IoPort->Data);
1337 } else {
1338
1339 WritePortW (AtapiScsiPrivate->PciIo, AtapiScsiPrivate->IoPort->Data, *ptrBuffer);
1340 }
1341
1342 ptrBuffer++;
1343
1344 }
1345 }
1346 //
1347 // After data transfer is completed, normally, DRQ bit should clear.
1348 //
1349 StatusDRQClear (AtapiScsiPrivate, TimeoutInMicroSeconds);
1350
1351 //
1352 // read status register to check whether error happens.
1353 //
1354 Status = AtapiPassThruCheckErrorStatus (AtapiScsiPrivate);
1355
1356 *ByteCount = ActualWordCount * 2;
1357
1358 return Status;
1359 }
1360
1361
1362 /**
1363 Read one byte from a specified I/O port.
1364
1365 @todo function comment is missing 'Routine Description:'
1366 @todo function comment is missing 'Arguments:'
1367 @todo function comment is missing 'Returns:'
1368 @todo PciIo - add argument and description to function comment
1369 @todo Port - add argument and description to function comment
1370 **/
1371 UINT8
1372 ReadPortB (
1373 IN EFI_PCI_IO_PROTOCOL *PciIo,
1374 IN UINT16 Port
1375 )
1376 {
1377 UINT8 Data;
1378
1379 Data = 0;
1380 PciIo->Io.Read (
1381 PciIo,
1382 EfiPciIoWidthUint8,
1383 EFI_PCI_IO_PASS_THROUGH_BAR,
1384 (UINT64) Port,
1385 1,
1386 &Data
1387 );
1388 return Data;
1389 }
1390
1391
1392 /**
1393 Read one word from a specified I/O port.
1394
1395 @todo function comment is missing 'Routine Description:'
1396 @todo function comment is missing 'Arguments:'
1397 @todo function comment is missing 'Returns:'
1398 @todo PciIo - add argument and description to function comment
1399 @todo Port - add argument and description to function comment
1400 **/
1401 UINT16
1402 ReadPortW (
1403 IN EFI_PCI_IO_PROTOCOL *PciIo,
1404 IN UINT16 Port
1405 )
1406 {
1407 UINT16 Data;
1408
1409 Data = 0;
1410 PciIo->Io.Read (
1411 PciIo,
1412 EfiPciIoWidthUint16,
1413 EFI_PCI_IO_PASS_THROUGH_BAR,
1414 (UINT64) Port,
1415 1,
1416 &Data
1417 );
1418 return Data;
1419 }
1420
1421
1422 /**
1423 Write one byte to a specified I/O port.
1424
1425 @todo function comment is missing 'Routine Description:'
1426 @todo function comment is missing 'Arguments:'
1427 @todo function comment is missing 'Returns:'
1428 @todo PciIo - add argument and description to function comment
1429 @todo Port - add argument and description to function comment
1430 @todo Data - add argument and description to function comment
1431 **/
1432 VOID
1433 WritePortB (
1434 IN EFI_PCI_IO_PROTOCOL *PciIo,
1435 IN UINT16 Port,
1436 IN UINT8 Data
1437 )
1438 {
1439
1440 PciIo->Io.Write (
1441 PciIo,
1442 EfiPciIoWidthUint8,
1443 EFI_PCI_IO_PASS_THROUGH_BAR,
1444 (UINT64) Port,
1445 1,
1446 &Data
1447 );
1448
1449 }
1450
1451
1452 /**
1453 Write one word to a specified I/O port.
1454
1455 @todo function comment is missing 'Routine Description:'
1456 @todo function comment is missing 'Arguments:'
1457 @todo function comment is missing 'Returns:'
1458 @todo PciIo - add argument and description to function comment
1459 @todo Port - add argument and description to function comment
1460 @todo Data - add argument and description to function comment
1461 **/
1462 VOID
1463 WritePortW (
1464 IN EFI_PCI_IO_PROTOCOL *PciIo,
1465 IN UINT16 Port,
1466 IN UINT16 Data
1467 )
1468 {
1469
1470 PciIo->Io.Write (
1471 PciIo,
1472 EfiPciIoWidthUint16,
1473 EFI_PCI_IO_PASS_THROUGH_BAR,
1474 (UINT64) Port,
1475 1,
1476 &Data
1477 );
1478 }
1479
1480 /**
1481 Check whether DRQ is clear in the Status Register. (BSY must also be cleared)
1482 If TimeoutInMicroSeconds is zero, this routine should wait infinitely for
1483 DRQ clear. Otherwise, it will return EFI_TIMEOUT when specified time is
1484 elapsed.
1485
1486 @todo function comment is missing 'Routine Description:'
1487 @todo function comment is missing 'Arguments:'
1488 @todo function comment is missing 'Returns:'
1489 @todo AtapiScsiPrivate - add argument and description to function comment
1490 @todo TimeoutInMicroSeconds - add argument and description to function comment
1491 @todo EFI_ABORTED - add return value to function comment
1492 @todo EFI_TIMEOUT - add return value to function comment
1493 @todo EFI_SUCCESS - add return value to function comment
1494 **/
1495 EFI_STATUS
1496 StatusDRQClear (
1497 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
1498 UINT64 TimeoutInMicroSeconds
1499 )
1500 {
1501 UINT64 Delay;
1502 UINT8 StatusRegister;
1503 UINT8 ErrRegister;
1504
1505 if (TimeoutInMicroSeconds == 0) {
1506 Delay = 2;
1507 } else {
1508 Delay = DivU64x32 (TimeoutInMicroSeconds, (UINT32) 30) + 1;
1509 }
1510
1511 do {
1512
1513 StatusRegister = ReadPortB (
1514 AtapiScsiPrivate->PciIo,
1515 AtapiScsiPrivate->IoPort->Reg.Status
1516 );
1517
1518 //
1519 // wait for BSY == 0 and DRQ == 0
1520 //
1521 if ((StatusRegister & (DRQ | BSY)) == 0) {
1522 break;
1523 }
1524 //
1525 // check whether the command is aborted by the device
1526 //
1527 if ((StatusRegister & (BSY | ERR)) == ERR) {
1528
1529 ErrRegister = ReadPortB (
1530 AtapiScsiPrivate->PciIo,
1531 AtapiScsiPrivate->IoPort->Reg1.Error
1532 );
1533 if ((ErrRegister & ABRT_ERR) == ABRT_ERR) {
1534
1535 return EFI_ABORTED;
1536 }
1537 }
1538 //
1539 // Stall for 30 us
1540 //
1541 gBS->Stall (30);
1542
1543 //
1544 // Loop infinitely if not meeting expected condition
1545 //
1546 if (TimeoutInMicroSeconds == 0) {
1547 Delay = 2;
1548 }
1549
1550 Delay--;
1551 } while (Delay);
1552
1553 if (Delay == 0) {
1554 return EFI_TIMEOUT;
1555 }
1556
1557 return EFI_SUCCESS;
1558 }
1559
1560 /**
1561 Check whether DRQ is clear in the Alternate Status Register.
1562 (BSY must also be cleared).
1563 If TimeoutInMicroSeconds is zero, this routine should wait infinitely for
1564 DRQ clear. Otherwise, it will return EFI_TIMEOUT when specified time is
1565 elapsed.
1566
1567 @todo function comment is missing 'Routine Description:'
1568 @todo function comment is missing 'Arguments:'
1569 @todo function comment is missing 'Returns:'
1570 @todo AtapiScsiPrivate - add argument and description to function comment
1571 @todo TimeoutInMicroSeconds - add argument and description to function comment
1572 @todo EFI_ABORTED - add return value to function comment
1573 @todo EFI_TIMEOUT - add return value to function comment
1574 @todo EFI_SUCCESS - add return value to function comment
1575 **/
1576 EFI_STATUS
1577 AltStatusDRQClear (
1578 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
1579 UINT64 TimeoutInMicroSeconds
1580 )
1581 {
1582 UINT64 Delay;
1583 UINT8 AltStatusRegister;
1584 UINT8 ErrRegister;
1585
1586 if (TimeoutInMicroSeconds == 0) {
1587 Delay = 2;
1588 } else {
1589 Delay = DivU64x32 (TimeoutInMicroSeconds, (UINT32) 30) + 1;
1590 }
1591
1592 do {
1593
1594 AltStatusRegister = ReadPortB (
1595 AtapiScsiPrivate->PciIo,
1596 AtapiScsiPrivate->IoPort->Alt.AltStatus
1597 );
1598
1599 //
1600 // wait for BSY == 0 and DRQ == 0
1601 //
1602 if ((AltStatusRegister & (DRQ | BSY)) == 0) {
1603 break;
1604 }
1605
1606 if ((AltStatusRegister & (BSY | ERR)) == ERR) {
1607
1608 ErrRegister = ReadPortB (
1609 AtapiScsiPrivate->PciIo,
1610 AtapiScsiPrivate->IoPort->Reg1.Error
1611 );
1612 if ((ErrRegister & ABRT_ERR) == ABRT_ERR) {
1613
1614 return EFI_ABORTED;
1615 }
1616 }
1617 //
1618 // Stall for 30 us
1619 //
1620 gBS->Stall (30);
1621
1622 //
1623 // Loop infinitely if not meeting expected condition
1624 //
1625 if (TimeoutInMicroSeconds == 0) {
1626 Delay = 2;
1627 }
1628
1629 Delay--;
1630 } while (Delay);
1631
1632 if (Delay == 0) {
1633 return EFI_TIMEOUT;
1634 }
1635
1636 return EFI_SUCCESS;
1637 }
1638
1639 /**
1640 Check whether DRQ is ready in the Status Register. (BSY must also be cleared)
1641 If TimeoutInMicroSeconds is zero, this routine should wait infinitely for
1642 DRQ ready. Otherwise, it will return EFI_TIMEOUT when specified time is
1643 elapsed.
1644
1645 @todo function comment is missing 'Routine Description:'
1646 @todo function comment is missing 'Arguments:'
1647 @todo function comment is missing 'Returns:'
1648 @todo AtapiScsiPrivate - add argument and description to function comment
1649 @todo TimeoutInMicroSeconds - add argument and description to function comment
1650 @todo EFI_ABORTED - add return value to function comment
1651 @todo EFI_TIMEOUT - add return value to function comment
1652 @todo EFI_SUCCESS - add return value to function comment
1653 **/
1654 EFI_STATUS
1655 StatusDRQReady (
1656 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
1657 UINT64 TimeoutInMicroSeconds
1658 )
1659 {
1660 UINT64 Delay;
1661 UINT8 StatusRegister;
1662 UINT8 ErrRegister;
1663
1664 if (TimeoutInMicroSeconds == 0) {
1665 Delay = 2;
1666 } else {
1667 Delay = DivU64x32 (TimeoutInMicroSeconds, (UINT32) 30) + 1;
1668 }
1669
1670 do {
1671 //
1672 // read Status Register will clear interrupt
1673 //
1674 StatusRegister = ReadPortB (
1675 AtapiScsiPrivate->PciIo,
1676 AtapiScsiPrivate->IoPort->Reg.Status
1677 );
1678
1679 //
1680 // BSY==0,DRQ==1
1681 //
1682 if ((StatusRegister & (BSY | DRQ)) == DRQ) {
1683 break;
1684 }
1685
1686 if ((StatusRegister & (BSY | ERR)) == ERR) {
1687
1688 ErrRegister = ReadPortB (
1689 AtapiScsiPrivate->PciIo,
1690 AtapiScsiPrivate->IoPort->Reg1.Error
1691 );
1692 if ((ErrRegister & ABRT_ERR) == ABRT_ERR) {
1693 return EFI_ABORTED;
1694 }
1695 }
1696
1697 //
1698 // Stall for 30 us
1699 //
1700 gBS->Stall (30);
1701
1702 //
1703 // Loop infinitely if not meeting expected condition
1704 //
1705 if (TimeoutInMicroSeconds == 0) {
1706 Delay = 2;
1707 }
1708
1709 Delay--;
1710 } while (Delay);
1711
1712 if (Delay == 0) {
1713 return EFI_TIMEOUT;
1714 }
1715
1716 return EFI_SUCCESS;
1717 }
1718
1719 /**
1720 Check whether DRQ is ready in the Alternate Status Register.
1721 (BSY must also be cleared)
1722 If TimeoutInMicroSeconds is zero, this routine should wait infinitely for
1723 DRQ ready. Otherwise, it will return EFI_TIMEOUT when specified time is
1724 elapsed.
1725
1726 @todo function comment is missing 'Routine Description:'
1727 @todo function comment is missing 'Arguments:'
1728 @todo function comment is missing 'Returns:'
1729 @todo AtapiScsiPrivate - add argument and description to function comment
1730 @todo TimeoutInMicroSeconds - add argument and description to function comment
1731 @todo EFI_ABORTED - add return value to function comment
1732 @todo EFI_TIMEOUT - add return value to function comment
1733 @todo EFI_SUCCESS - add return value to function comment
1734 **/
1735 EFI_STATUS
1736 AltStatusDRQReady (
1737 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
1738 UINT64 TimeoutInMicroSeconds
1739 )
1740 {
1741 UINT64 Delay;
1742 UINT8 AltStatusRegister;
1743 UINT8 ErrRegister;
1744
1745 if (TimeoutInMicroSeconds == 0) {
1746 Delay = 2;
1747 } else {
1748 Delay = DivU64x32 (TimeoutInMicroSeconds, (UINT32) 30) + 1;
1749 }
1750
1751 do {
1752 //
1753 // read Status Register will clear interrupt
1754 //
1755 AltStatusRegister = ReadPortB (
1756 AtapiScsiPrivate->PciIo,
1757 AtapiScsiPrivate->IoPort->Alt.AltStatus
1758 );
1759 //
1760 // BSY==0,DRQ==1
1761 //
1762 if ((AltStatusRegister & (BSY | DRQ)) == DRQ) {
1763 break;
1764 }
1765
1766 if ((AltStatusRegister & (BSY | ERR)) == ERR) {
1767
1768 ErrRegister = ReadPortB (
1769 AtapiScsiPrivate->PciIo,
1770 AtapiScsiPrivate->IoPort->Reg1.Error
1771 );
1772 if ((ErrRegister & ABRT_ERR) == ABRT_ERR) {
1773 return EFI_ABORTED;
1774 }
1775 }
1776
1777 //
1778 // Stall for 30 us
1779 //
1780 gBS->Stall (30);
1781
1782 //
1783 // Loop infinitely if not meeting expected condition
1784 //
1785 if (TimeoutInMicroSeconds == 0) {
1786 Delay = 2;
1787 }
1788
1789 Delay--;
1790 } while (Delay);
1791
1792 if (Delay == 0) {
1793 return EFI_TIMEOUT;
1794 }
1795
1796 return EFI_SUCCESS;
1797 }
1798
1799 /**
1800 Check whether BSY is clear in the Status Register.
1801 If TimeoutInMicroSeconds is zero, this routine should wait infinitely for
1802 BSY clear. Otherwise, it will return EFI_TIMEOUT when specified time is
1803 elapsed.
1804
1805 @todo function comment is missing 'Routine Description:'
1806 @todo function comment is missing 'Arguments:'
1807 @todo function comment is missing 'Returns:'
1808 @todo AtapiScsiPrivate - add argument and description to function comment
1809 @todo TimeoutInMicroSeconds - add argument and description to function comment
1810 @todo EFI_TIMEOUT - add return value to function comment
1811 @todo EFI_SUCCESS - add return value to function comment
1812 **/
1813 EFI_STATUS
1814 StatusWaitForBSYClear (
1815 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
1816 UINT64 TimeoutInMicroSeconds
1817 )
1818 {
1819 UINT64 Delay;
1820 UINT8 StatusRegister;
1821
1822 if (TimeoutInMicroSeconds == 0) {
1823 Delay = 2;
1824 } else {
1825 Delay = DivU64x32 (TimeoutInMicroSeconds, (UINT32) 30) + 1;
1826 }
1827
1828 do {
1829
1830 StatusRegister = ReadPortB (
1831 AtapiScsiPrivate->PciIo,
1832 AtapiScsiPrivate->IoPort->Reg.Status
1833 );
1834 if ((StatusRegister & BSY) == 0x00) {
1835 break;
1836 }
1837
1838 //
1839 // Stall for 30 us
1840 //
1841 gBS->Stall (30);
1842
1843 //
1844 // Loop infinitely if not meeting expected condition
1845 //
1846 if (TimeoutInMicroSeconds == 0) {
1847 Delay = 2;
1848 }
1849
1850 Delay--;
1851 } while (Delay);
1852
1853 if (Delay == 0) {
1854 return EFI_TIMEOUT;
1855 }
1856
1857 return EFI_SUCCESS;
1858 }
1859
1860 /**
1861 Check whether BSY is clear in the Alternate Status Register.
1862 If TimeoutInMicroSeconds is zero, this routine should wait infinitely for
1863 BSY clear. Otherwise, it will return EFI_TIMEOUT when specified time is
1864 elapsed.
1865
1866 @todo function comment is missing 'Routine Description:'
1867 @todo function comment is missing 'Arguments:'
1868 @todo function comment is missing 'Returns:'
1869 @todo AtapiScsiPrivate - add argument and description to function comment
1870 @todo TimeoutInMicroSeconds - add argument and description to function comment
1871 @todo EFI_TIMEOUT - add return value to function comment
1872 @todo EFI_SUCCESS - add return value to function comment
1873 **/
1874 EFI_STATUS
1875 AltStatusWaitForBSYClear (
1876 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
1877 UINT64 TimeoutInMicroSeconds
1878 )
1879 {
1880 UINT64 Delay;
1881 UINT8 AltStatusRegister;
1882
1883 if (TimeoutInMicroSeconds == 0) {
1884 Delay = 2;
1885 } else {
1886 Delay = DivU64x32 (TimeoutInMicroSeconds, (UINT32) 30) + 1;
1887 }
1888
1889 do {
1890
1891 AltStatusRegister = ReadPortB (
1892 AtapiScsiPrivate->PciIo,
1893 AtapiScsiPrivate->IoPort->Alt.AltStatus
1894 );
1895 if ((AltStatusRegister & BSY) == 0x00) {
1896 break;
1897 }
1898
1899 //
1900 // Stall for 30 us
1901 //
1902 gBS->Stall (30);
1903 //
1904 // Loop infinitely if not meeting expected condition
1905 //
1906 if (TimeoutInMicroSeconds == 0) {
1907 Delay = 2;
1908 }
1909
1910 Delay--;
1911 } while (Delay);
1912
1913 if (Delay == 0) {
1914 return EFI_TIMEOUT;
1915 }
1916
1917 return EFI_SUCCESS;
1918 }
1919
1920 /**
1921 Check whether DRDY is ready in the Status Register.
1922 (BSY must also be cleared)
1923 If TimeoutInMicroSeconds is zero, this routine should wait infinitely for
1924 DRDY ready. Otherwise, it will return EFI_TIMEOUT when specified time is
1925 elapsed.
1926
1927 @todo function comment is missing 'Routine Description:'
1928 @todo function comment is missing 'Arguments:'
1929 @todo function comment is missing 'Returns:'
1930 @todo AtapiScsiPrivate - add argument and description to function comment
1931 @todo TimeoutInMicroSeconds - add argument and description to function comment
1932 @todo EFI_ABORTED - add return value to function comment
1933 @todo EFI_TIMEOUT - add return value to function comment
1934 @todo EFI_SUCCESS - add return value to function comment
1935 **/
1936 EFI_STATUS
1937 StatusDRDYReady (
1938 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
1939 UINT64 TimeoutInMicroSeconds
1940 )
1941 {
1942 UINT64 Delay;
1943 UINT8 StatusRegister;
1944 UINT8 ErrRegister;
1945
1946 if (TimeoutInMicroSeconds == 0) {
1947 Delay = 2;
1948 } else {
1949 Delay = DivU64x32 (TimeoutInMicroSeconds, (UINT32) 30) + 1;
1950 }
1951
1952 do {
1953 StatusRegister = ReadPortB (
1954 AtapiScsiPrivate->PciIo,
1955 AtapiScsiPrivate->IoPort->Reg.Status
1956 );
1957 //
1958 // BSY == 0 , DRDY == 1
1959 //
1960 if ((StatusRegister & (DRDY | BSY)) == DRDY) {
1961 break;
1962 }
1963
1964 if ((StatusRegister & (BSY | ERR)) == ERR) {
1965
1966 ErrRegister = ReadPortB (
1967 AtapiScsiPrivate->PciIo,
1968 AtapiScsiPrivate->IoPort->Reg1.Error
1969 );
1970 if ((ErrRegister & ABRT_ERR) == ABRT_ERR) {
1971 return EFI_ABORTED;
1972 }
1973 }
1974
1975 //
1976 // Stall for 30 us
1977 //
1978 gBS->Stall (30);
1979 //
1980 // Loop infinitely if not meeting expected condition
1981 //
1982 if (TimeoutInMicroSeconds == 0) {
1983 Delay = 2;
1984 }
1985
1986 Delay--;
1987 } while (Delay);
1988
1989 if (Delay == 0) {
1990 return EFI_TIMEOUT;
1991 }
1992
1993 return EFI_SUCCESS;
1994 }
1995
1996 /**
1997 Check whether DRDY is ready in the Alternate Status Register.
1998 (BSY must also be cleared)
1999 If TimeoutInMicroSeconds is zero, this routine should wait infinitely for
2000 DRDY ready. Otherwise, it will return EFI_TIMEOUT when specified time is
2001 elapsed.
2002
2003 @todo function comment is missing 'Routine Description:'
2004 @todo function comment is missing 'Arguments:'
2005 @todo function comment is missing 'Returns:'
2006 @todo AtapiScsiPrivate - add argument and description to function comment
2007 @todo TimeoutInMicroSeconds - add argument and description to function comment
2008 @todo EFI_ABORTED - add return value to function comment
2009 @todo EFI_TIMEOUT - add return value to function comment
2010 @todo EFI_SUCCESS - add return value to function comment
2011 **/
2012 EFI_STATUS
2013 AltStatusDRDYReady (
2014 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
2015 UINT64 TimeoutInMicroSeconds
2016 )
2017 {
2018 UINT64 Delay;
2019 UINT8 AltStatusRegister;
2020 UINT8 ErrRegister;
2021
2022 if (TimeoutInMicroSeconds == 0) {
2023 Delay = 2;
2024 } else {
2025 Delay = DivU64x32 (TimeoutInMicroSeconds, (UINT32) 30) + 1;
2026 }
2027
2028 do {
2029 AltStatusRegister = ReadPortB (
2030 AtapiScsiPrivate->PciIo,
2031 AtapiScsiPrivate->IoPort->Alt.AltStatus
2032 );
2033 //
2034 // BSY == 0 , DRDY == 1
2035 //
2036 if ((AltStatusRegister & (DRDY | BSY)) == DRDY) {
2037 break;
2038 }
2039
2040 if ((AltStatusRegister & (BSY | ERR)) == ERR) {
2041
2042 ErrRegister = ReadPortB (
2043 AtapiScsiPrivate->PciIo,
2044 AtapiScsiPrivate->IoPort->Reg1.Error
2045 );
2046 if ((ErrRegister & ABRT_ERR) == ABRT_ERR) {
2047 return EFI_ABORTED;
2048 }
2049 }
2050
2051 //
2052 // Stall for 30 us
2053 //
2054 gBS->Stall (30);
2055 //
2056 // Loop infinitely if not meeting expected condition
2057 //
2058 if (TimeoutInMicroSeconds == 0) {
2059 Delay = 2;
2060 }
2061
2062 Delay--;
2063 } while (Delay);
2064
2065 if (Delay == 0) {
2066 return EFI_TIMEOUT;
2067 }
2068
2069 return EFI_SUCCESS;
2070 }
2071
2072 /**
2073 Check Error Register for Error Information.
2074
2075 @todo function comment is missing 'Routine Description:'
2076 @todo function comment is missing 'Arguments:'
2077 @todo function comment is missing 'Returns:'
2078 @todo AtapiScsiPrivate - add argument and description to function comment
2079 @todo EFI_SUCCESS - add return value to function comment
2080 @todo EFI_DEVICE_ERROR - add return value to function comment
2081 **/
2082 EFI_STATUS
2083 AtapiPassThruCheckErrorStatus (
2084 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate
2085 )
2086 {
2087 UINT8 StatusRegister;
2088 UINT8 ErrorRegister;
2089
2090 StatusRegister = ReadPortB (
2091 AtapiScsiPrivate->PciIo,
2092 AtapiScsiPrivate->IoPort->Reg.Status
2093 );
2094
2095 DEBUG_CODE_BEGIN ();
2096
2097 if (StatusRegister & DWF) {
2098 DEBUG (
2099 (EFI_D_BLKIO,
2100 "AtapiPassThruCheckErrorStatus()-- %02x : Error : Write Fault\n",
2101 StatusRegister)
2102 );
2103 }
2104
2105 if (StatusRegister & CORR) {
2106 DEBUG (
2107 (EFI_D_BLKIO,
2108 "AtapiPassThruCheckErrorStatus()-- %02x : Error : Corrected Data\n",
2109 StatusRegister)
2110 );
2111 }
2112
2113 if (StatusRegister & ERR) {
2114 ErrorRegister = ReadPortB (AtapiScsiPrivate->PciIo, AtapiScsiPrivate->IoPort->Reg1.Error);
2115
2116
2117 if (ErrorRegister & BBK_ERR) {
2118 DEBUG (
2119 (EFI_D_BLKIO,
2120 "AtapiPassThruCheckErrorStatus()-- %02x : Error : Bad Block Detected\n",
2121 ErrorRegister)
2122 );
2123 }
2124
2125 if (ErrorRegister & UNC_ERR) {
2126 DEBUG (
2127 (EFI_D_BLKIO,
2128 "AtapiPassThruCheckErrorStatus()-- %02x : Error : Uncorrectable Data\n",
2129 ErrorRegister)
2130 );
2131 }
2132
2133 if (ErrorRegister & MC_ERR) {
2134 DEBUG (
2135 (EFI_D_BLKIO,
2136 "AtapiPassThruCheckErrorStatus()-- %02x : Error : Media Change\n",
2137 ErrorRegister)
2138 );
2139 }
2140
2141 if (ErrorRegister & ABRT_ERR) {
2142 DEBUG (
2143 (EFI_D_BLKIO,
2144 "AtapiPassThruCheckErrorStatus()-- %02x : Error : Abort\n",
2145 ErrorRegister)
2146 );
2147 }
2148
2149 if (ErrorRegister & TK0NF_ERR) {
2150 DEBUG (
2151 (EFI_D_BLKIO,
2152 "AtapiPassThruCheckErrorStatus()-- %02x : Error : Track 0 Not Found\n",
2153 ErrorRegister)
2154 );
2155 }
2156
2157 if (ErrorRegister & AMNF_ERR) {
2158 DEBUG (
2159 (EFI_D_BLKIO,
2160 "AtapiPassThruCheckErrorStatus()-- %02x : Error : Address Mark Not Found\n",
2161 ErrorRegister)
2162 );
2163 }
2164 }
2165
2166 DEBUG_CODE_END ();
2167
2168 if ((StatusRegister & (ERR | DWF | CORR)) == 0) {
2169 return EFI_SUCCESS;
2170 }
2171
2172
2173 return EFI_DEVICE_ERROR;
2174 }