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