ac12be4ee048aed5d5406620043e568f782d2a3c
[mirror_edk2.git] / OptionRomPkg / AtapiPassThruDxe / 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
16 static SCSI_COMMAND_SET gEndTable = { 0xff, (DATA_DIRECTION) 0xff };
17
18 ///
19 /// This table contains all the supported ATAPI commands.
20 ///
21 static SCSI_COMMAND_SET gSupportedATAPICommands[] = {
22 { OP_INQUIRY, DataIn },
23 { OP_LOAD_UNLOAD_CD, NoData },
24 { OP_MECHANISM_STATUS, DataIn },
25 { OP_MODE_SELECT_10, DataOut },
26 { OP_MODE_SENSE_10, DataIn },
27 { OP_PAUSE_RESUME, NoData },
28 { OP_PLAY_AUDIO_10, DataIn },
29 { OP_PLAY_AUDIO_MSF, DataIn },
30 { OP_PLAY_CD, DataIn },
31 { OP_PLAY_CD_MSF, DataIn },
32 { OP_PREVENT_ALLOW_MEDIUM_REMOVAL,NoData },
33 { OP_READ_10, DataIn },
34 { OP_READ_12, DataIn },
35 { OP_READ_CAPACITY, DataIn },
36 { OP_READ_CD, DataIn },
37 { OP_READ_CD_MSF, DataIn },
38 { OP_READ_HEADER, DataIn },
39 { OP_READ_SUB_CHANNEL, DataIn },
40 { OP_READ_TOC, DataIn },
41 { OP_REQUEST_SENSE, DataIn },
42 { OP_SCAN, NoData },
43 { OP_SEEK_10, NoData },
44 { OP_SET_CD_SPEED, DataOut },
45 { OP_STOPPLAY_SCAN, NoData },
46 { OP_START_STOP_UNIT, NoData },
47 { OP_TEST_UNIT_READY, NoData },
48 { OP_FORMAT_UNIT, DataOut },
49 { OP_READ_FORMAT_CAPACITIES, DataIn },
50 { OP_VERIFY, DataOut },
51 { OP_WRITE_10, DataOut },
52 { OP_WRITE_12, DataOut },
53 { OP_WRITE_AND_VERIFY, DataOut },
54 { 0xff, (DATA_DIRECTION) 0xff }
55 };
56
57 GLOBAL_REMOVE_IF_UNREFERENCED EFI_SCSI_PASS_THRU_MODE gScsiPassThruMode = {
58 L"ATAPI Controller",
59 L"ATAPI Channel",
60 4,
61 EFI_SCSI_PASS_THRU_ATTRIBUTES_PHYSICAL | EFI_SCSI_PASS_THRU_ATTRIBUTES_LOGICAL,
62 0
63 };
64
65 GLOBAL_REMOVE_IF_UNREFERENCED EFI_SCSI_PASS_THRU_PROTOCOL gScsiPassThruProtocolTemplate = {
66 &gScsiPassThruMode,
67 AtapiScsiPassThruFunction,
68 AtapiScsiPassThruGetNextDevice,
69 AtapiScsiPassThruBuildDevicePath,
70 AtapiScsiPassThruGetTargetLun,
71 AtapiScsiPassThruResetChannel,
72 AtapiScsiPassThruResetTarget
73 };
74
75 GLOBAL_REMOVE_IF_UNREFERENCED EFI_EXT_SCSI_PASS_THRU_MODE gExtScsiPassThruMode = {
76 4,
77 EFI_EXT_SCSI_PASS_THRU_ATTRIBUTES_PHYSICAL | EFI_EXT_SCSI_PASS_THRU_ATTRIBUTES_LOGICAL,
78 0
79 };
80
81 GLOBAL_REMOVE_IF_UNREFERENCED EFI_EXT_SCSI_PASS_THRU_PROTOCOL gExtScsiPassThruProtocolTemplate = {
82 &gExtScsiPassThruMode,
83 AtapiExtScsiPassThruFunction,
84 AtapiExtScsiPassThruGetNextTargetLun,
85 AtapiExtScsiPassThruBuildDevicePath,
86 AtapiExtScsiPassThruGetTargetLun,
87 AtapiExtScsiPassThruResetChannel,
88 AtapiExtScsiPassThruResetTarget,
89 AtapiExtScsiPassThruGetNextTarget
90 };
91
92 EFI_DRIVER_BINDING_PROTOCOL gAtapiScsiPassThruDriverBinding = {
93 AtapiScsiPassThruDriverBindingSupported,
94 AtapiScsiPassThruDriverBindingStart,
95 AtapiScsiPassThruDriverBindingStop,
96 0x10,
97 NULL,
98 NULL
99 };
100
101 EFI_STATUS
102 EFIAPI
103 AtapiScsiPassThruDriverBindingSupported (
104 IN EFI_DRIVER_BINDING_PROTOCOL *This,
105 IN EFI_HANDLE Controller,
106 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
107 )
108 /*++
109
110 Routine Description:
111 Test to see if this driver supports ControllerHandle. Any ControllerHandle
112 that has gEfiPciIoProtocolGuid installed and is IDE Controller it will be supported.
113
114 Arguments:
115
116 This - Protocol instance pointer.
117 Controller - Handle of device to test
118 RemainingDevicePath - Not used
119
120 Returns:
121 EFI_STATUS
122
123 --*/
124 {
125 EFI_STATUS Status;
126 EFI_PCI_IO_PROTOCOL *PciIo;
127 PCI_TYPE00 Pci;
128
129
130 //
131 // Open the IO Abstraction(s) needed to perform the supported test
132 //
133 Status = gBS->OpenProtocol (
134 Controller,
135 &gEfiPciIoProtocolGuid,
136 (VOID **) &PciIo,
137 This->DriverBindingHandle,
138 Controller,
139 EFI_OPEN_PROTOCOL_BY_DRIVER
140 );
141 if (EFI_ERROR (Status)) {
142 return Status;
143 }
144 //
145 // Use the PCI I/O Protocol to see if Controller is a IDE Controller that
146 // can be managed by this driver. Read the PCI Configuration Header
147 // for this device.
148 //
149 Status = PciIo->Pci.Read (
150 PciIo,
151 EfiPciIoWidthUint32,
152 0,
153 sizeof (Pci) / sizeof (UINT32),
154 &Pci
155 );
156 if (EFI_ERROR (Status)) {
157 gBS->CloseProtocol (
158 Controller,
159 &gEfiPciIoProtocolGuid,
160 This->DriverBindingHandle,
161 Controller
162 );
163 return EFI_UNSUPPORTED;
164 }
165
166 if (Pci.Hdr.ClassCode[2] != PCI_CLASS_MASS_STORAGE || Pci.Hdr.ClassCode[1] != PCI_CLASS_IDE) {
167
168 Status = EFI_UNSUPPORTED;
169 }
170
171 gBS->CloseProtocol (
172 Controller,
173 &gEfiPciIoProtocolGuid,
174 This->DriverBindingHandle,
175 Controller
176 );
177
178 return Status;
179 }
180
181 EFI_STATUS
182 EFIAPI
183 AtapiScsiPassThruDriverBindingStart (
184 IN EFI_DRIVER_BINDING_PROTOCOL *This,
185 IN EFI_HANDLE Controller,
186 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
187 )
188 /*++
189
190 Routine Description:
191 Create handles for IDE channels specified by RemainingDevicePath.
192 Install SCSI Pass Thru Protocol onto each created handle.
193
194 Arguments:
195
196 This - Protocol instance pointer.
197 Controller - Handle of device to test
198 RemainingDevicePath - Not used
199
200 Returns:
201 EFI_STATUS
202
203 --*/
204 {
205 EFI_STATUS Status;
206 EFI_PCI_IO_PROTOCOL *PciIo;
207 UINT64 Supports;
208 UINT64 OriginalPciAttributes;
209 BOOLEAN PciAttributesSaved;
210
211 PciIo = NULL;
212 Status = gBS->OpenProtocol (
213 Controller,
214 &gEfiPciIoProtocolGuid,
215 (VOID **) &PciIo,
216 This->DriverBindingHandle,
217 Controller,
218 EFI_OPEN_PROTOCOL_BY_DRIVER
219 );
220 if (EFI_ERROR (Status)) {
221 return Status;
222 }
223
224 PciAttributesSaved = FALSE;
225 //
226 // Save original PCI attributes
227 //
228 Status = PciIo->Attributes (
229 PciIo,
230 EfiPciIoAttributeOperationGet,
231 0,
232 &OriginalPciAttributes
233 );
234
235 if (EFI_ERROR (Status)) {
236 goto Done;
237 }
238 PciAttributesSaved = TRUE;
239
240 Status = PciIo->Attributes (
241 PciIo,
242 EfiPciIoAttributeOperationSupported,
243 0,
244 &Supports
245 );
246 if (!EFI_ERROR (Status)) {
247 Supports &= (EFI_PCI_DEVICE_ENABLE |
248 EFI_PCI_IO_ATTRIBUTE_IDE_PRIMARY_IO |
249 EFI_PCI_IO_ATTRIBUTE_IDE_SECONDARY_IO);
250 Status = PciIo->Attributes (
251 PciIo,
252 EfiPciIoAttributeOperationEnable,
253 Supports,
254 NULL
255 );
256 }
257 if (EFI_ERROR (Status)) {
258 goto Done;
259 }
260
261 //
262 // Create SCSI Pass Thru instance for the IDE channel.
263 //
264 Status = RegisterAtapiScsiPassThru (This, Controller, PciIo, OriginalPciAttributes);
265
266 Done:
267 if (EFI_ERROR (Status)) {
268 if (PciAttributesSaved == TRUE) {
269 //
270 // Restore original PCI attributes
271 //
272 PciIo->Attributes (
273 PciIo,
274 EfiPciIoAttributeOperationSet,
275 OriginalPciAttributes,
276 NULL
277 );
278 }
279
280 gBS->CloseProtocol (
281 Controller,
282 &gEfiPciIoProtocolGuid,
283 This->DriverBindingHandle,
284 Controller
285 );
286 }
287
288 return Status;
289 }
290
291 EFI_STATUS
292 EFIAPI
293 AtapiScsiPassThruDriverBindingStop (
294 IN EFI_DRIVER_BINDING_PROTOCOL *This,
295 IN EFI_HANDLE Controller,
296 IN UINTN NumberOfChildren,
297 IN EFI_HANDLE *ChildHandleBuffer
298 )
299 /*++
300
301 Routine Description:
302
303 Stop this driver on ControllerHandle. Support stoping any child handles
304 created by this driver.
305
306 Arguments:
307
308 This - Protocol instance pointer.
309 Controller - Handle of device to stop driver on
310 NumberOfChildren - Number of Children in the ChildHandleBuffer
311 ChildHandleBuffer - List of handles for the children we need to stop.
312
313 Returns:
314
315 EFI_STATUS
316
317 --*/
318 {
319 EFI_STATUS Status;
320 EFI_SCSI_PASS_THRU_PROTOCOL *ScsiPassThru;
321 EFI_EXT_SCSI_PASS_THRU_PROTOCOL *ExtScsiPassThru;
322 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate;
323
324 if (FeaturePcdGet (PcdSupportScsiPassThru)) {
325 Status = gBS->OpenProtocol (
326 Controller,
327 &gEfiScsiPassThruProtocolGuid,
328 (VOID **) &ScsiPassThru,
329 This->DriverBindingHandle,
330 Controller,
331 EFI_OPEN_PROTOCOL_GET_PROTOCOL
332 );
333 if (EFI_ERROR (Status)) {
334 return Status;
335 }
336 AtapiScsiPrivate = ATAPI_SCSI_PASS_THRU_DEV_FROM_THIS (ScsiPassThru);
337 if (FeaturePcdGet (PcdSupportExtScsiPassThru)) {
338 Status = gBS->UninstallMultipleProtocolInterfaces (
339 Controller,
340 &gEfiScsiPassThruProtocolGuid,
341 &AtapiScsiPrivate->ScsiPassThru,
342 &gEfiExtScsiPassThruProtocolGuid,
343 &AtapiScsiPrivate->ExtScsiPassThru,
344 NULL
345 );
346 } else {
347 Status = gBS->UninstallMultipleProtocolInterfaces (
348 Controller,
349 &gEfiScsiPassThruProtocolGuid,
350 &AtapiScsiPrivate->ScsiPassThru,
351 NULL
352 );
353 }
354 } else {
355 Status = gBS->OpenProtocol (
356 Controller,
357 &gEfiExtScsiPassThruProtocolGuid,
358 (VOID **) &ExtScsiPassThru,
359 This->DriverBindingHandle,
360 Controller,
361 EFI_OPEN_PROTOCOL_GET_PROTOCOL
362 );
363 if (EFI_ERROR (Status)) {
364 return Status;
365 }
366 AtapiScsiPrivate = ATAPI_EXT_SCSI_PASS_THRU_DEV_FROM_THIS (ExtScsiPassThru);
367 Status = gBS->UninstallMultipleProtocolInterfaces (
368 Controller,
369 &gEfiExtScsiPassThruProtocolGuid,
370 &AtapiScsiPrivate->ExtScsiPassThru,
371 NULL
372 );
373 }
374 if (EFI_ERROR (Status)) {
375 return Status;
376 }
377
378 //
379 // Restore original PCI attributes
380 //
381 AtapiScsiPrivate->PciIo->Attributes (
382 AtapiScsiPrivate->PciIo,
383 EfiPciIoAttributeOperationSet,
384 AtapiScsiPrivate->OriginalPciAttributes,
385 NULL
386 );
387
388 gBS->CloseProtocol (
389 Controller,
390 &gEfiPciIoProtocolGuid,
391 This->DriverBindingHandle,
392 Controller
393 );
394
395 gBS->FreePool (AtapiScsiPrivate);
396
397 return EFI_SUCCESS;
398 }
399
400 EFI_STATUS
401 RegisterAtapiScsiPassThru (
402 IN EFI_DRIVER_BINDING_PROTOCOL *This,
403 IN EFI_HANDLE Controller,
404 IN EFI_PCI_IO_PROTOCOL *PciIo,
405 IN UINT64 OriginalPciAttributes
406 )
407 /*++
408
409 Routine Description:
410 Attaches SCSI Pass Thru Protocol for specified IDE channel.
411
412 Arguments:
413 This - Protocol instance pointer.
414 Controller - Parent device handle to the IDE channel.
415 PciIo - PCI I/O protocol attached on the "Controller".
416
417 Returns:
418 Always return EFI_SUCCESS unless installing SCSI Pass Thru Protocol failed.
419
420 --*/
421 {
422 EFI_STATUS Status;
423 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate;
424 IDE_REGISTERS_BASE_ADDR IdeRegsBaseAddr[ATAPI_MAX_CHANNEL];
425
426 AtapiScsiPrivate = AllocateZeroPool (sizeof (ATAPI_SCSI_PASS_THRU_DEV));
427 if (AtapiScsiPrivate == NULL) {
428 return EFI_OUT_OF_RESOURCES;
429 }
430
431 AtapiScsiPrivate->Signature = ATAPI_SCSI_PASS_THRU_DEV_SIGNATURE;
432 AtapiScsiPrivate->Handle = Controller;
433
434 //
435 // will reset the IoPort inside each API function.
436 //
437 AtapiScsiPrivate->IoPort = NULL;
438 AtapiScsiPrivate->PciIo = PciIo;
439 AtapiScsiPrivate->OriginalPciAttributes = OriginalPciAttributes;
440
441 //
442 // Obtain IDE IO port registers' base addresses
443 //
444 Status = GetIdeRegistersBaseAddr (PciIo, IdeRegsBaseAddr);
445 if (EFI_ERROR (Status)) {
446 return Status;
447 }
448
449 InitAtapiIoPortRegisters(AtapiScsiPrivate, IdeRegsBaseAddr);
450
451 //
452 // Initialize the LatestTargetId to MAX_TARGET_ID.
453 //
454 AtapiScsiPrivate->LatestTargetId = MAX_TARGET_ID;
455 AtapiScsiPrivate->LatestLun = 0;
456
457 Status = InstallScsiPassThruProtocols (&Controller, AtapiScsiPrivate);
458
459 return Status;
460 }
461
462 EFI_STATUS
463 EFIAPI
464 AtapiScsiPassThruFunction (
465 IN EFI_SCSI_PASS_THRU_PROTOCOL *This,
466 IN UINT32 Target,
467 IN UINT64 Lun,
468 IN OUT EFI_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet,
469 IN EFI_EVENT Event OPTIONAL
470 )
471 /*++
472
473 Routine Description:
474
475 Implements EFI_SCSI_PASS_THRU_PROTOCOL.PassThru() function.
476
477 Arguments:
478
479 This: The EFI_SCSI_PASS_THRU_PROTOCOL instance.
480 Target: The Target ID of the ATAPI device to send the SCSI
481 Request Packet. To ATAPI devices attached on an IDE
482 Channel, Target ID 0 indicates Master device;Target
483 ID 1 indicates Slave device.
484 Lun: The LUN of the ATAPI device to send the SCSI Request
485 Packet. To the ATAPI device, Lun is always 0.
486 Packet: The SCSI Request Packet to send to the ATAPI device
487 specified by Target and Lun.
488 Event: If non-blocking I/O is not supported then Event is ignored,
489 and blocking I/O is performed.
490 If Event is NULL, then blocking I/O is performed.
491 If Event is not NULL and non blocking I/O is supported,
492 then non-blocking I/O is performed, and Event will be signaled
493 when the SCSI Request Packet completes.
494
495 Returns:
496
497 EFI_STATUS
498
499 --*/
500 {
501 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate;
502 EFI_STATUS Status;
503
504 AtapiScsiPrivate = ATAPI_SCSI_PASS_THRU_DEV_FROM_THIS (This);
505
506 //
507 // Target is not allowed beyond MAX_TARGET_ID
508 //
509 if ((Target > MAX_TARGET_ID) || (Lun != 0)) {
510 return EFI_INVALID_PARAMETER;
511 }
512
513 //
514 // check the data fields in Packet parameter.
515 //
516 Status = CheckSCSIRequestPacket (Packet);
517 if (EFI_ERROR (Status)) {
518 return Status;
519 }
520
521 //
522 // If Request Packet targets at the IDE channel itself,
523 // do nothing.
524 //
525 if (Target == This->Mode->AdapterId) {
526 Packet->TransferLength = 0;
527 return EFI_SUCCESS;
528 }
529
530 //
531 // According to Target ID, reset the Atapi I/O Register mapping
532 // (Target Id in [0,1] area, using AtapiIoPortRegisters[0],
533 // Target Id in [2,3] area, using AtapiIoPortRegisters[1]
534 //
535 if ((Target / 2) == 0) {
536 Target = Target % 2;
537 AtapiScsiPrivate->IoPort = &AtapiScsiPrivate->AtapiIoPortRegisters[0];
538 } else {
539 Target = Target % 2;
540 AtapiScsiPrivate->IoPort = &AtapiScsiPrivate->AtapiIoPortRegisters[1];
541 }
542
543 //
544 // the ATAPI SCSI interface does not support non-blocking I/O
545 // ignore the Event parameter
546 //
547 // Performs blocking I/O.
548 //
549 Status = SubmitBlockingIoCommand (AtapiScsiPrivate, Target, Packet);
550 return Status;
551 }
552
553 EFI_STATUS
554 EFIAPI
555 AtapiScsiPassThruGetNextDevice (
556 IN EFI_SCSI_PASS_THRU_PROTOCOL *This,
557 IN OUT UINT32 *Target,
558 IN OUT UINT64 *Lun
559 )
560 /*++
561
562 Routine Description:
563
564 Used to retrieve the list of legal Target IDs for SCSI devices
565 on a SCSI channel.
566
567 Arguments:
568
569 This - Protocol instance pointer.
570 Target - On input, a pointer to the Target ID of a SCSI
571 device present on the SCSI channel. On output,
572 a pointer to the Target ID of the next SCSI device
573 present on a SCSI channel. An input value of
574 0xFFFFFFFF retrieves the Target ID of the first
575 SCSI device present on a SCSI channel.
576 Lun - On input, a pointer to the LUN of a SCSI device
577 present on the SCSI channel. On output, a pointer
578 to the LUN of the next SCSI device present on
579 a SCSI channel.
580 Returns:
581
582 EFI_SUCCESS - The Target ID and Lun of the next SCSI device
583 on the SCSI channel was returned in Target and Lun.
584 EFI_NOT_FOUND - There are no more SCSI devices on this SCSI channel.
585 EFI_INVALID_PARAMETER - Target is not 0xFFFFFFFF,and Target and Lun were not
586 returned on a previous call to GetNextDevice().
587 --*/
588 {
589 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate;
590
591 //
592 // Retrieve Device Private Data Structure.
593 //
594 AtapiScsiPrivate = ATAPI_SCSI_PASS_THRU_DEV_FROM_THIS (This);
595
596 //
597 // Check whether Target is valid.
598 //
599 if (Target == NULL || Lun == NULL) {
600 return EFI_INVALID_PARAMETER;
601 }
602
603 if ((*Target != 0xFFFFFFFF) &&
604 ((*Target != AtapiScsiPrivate->LatestTargetId) ||
605 (*Lun != AtapiScsiPrivate->LatestLun))) {
606 return EFI_INVALID_PARAMETER;
607 }
608
609 if (*Target == MAX_TARGET_ID) {
610 return EFI_NOT_FOUND;
611 }
612
613 if (*Target == 0xFFFFFFFF) {
614 *Target = 0;
615 } else {
616 *Target = AtapiScsiPrivate->LatestTargetId + 1;
617 }
618
619 *Lun = 0;
620
621 //
622 // Update the LatestTargetId.
623 //
624 AtapiScsiPrivate->LatestTargetId = *Target;
625 AtapiScsiPrivate->LatestLun = *Lun;
626
627 return EFI_SUCCESS;
628
629 }
630
631 EFI_STATUS
632 EFIAPI
633 AtapiScsiPassThruBuildDevicePath (
634 IN EFI_SCSI_PASS_THRU_PROTOCOL *This,
635 IN UINT32 Target,
636 IN UINT64 Lun,
637 IN OUT EFI_DEVICE_PATH_PROTOCOL **DevicePath
638 )
639 /*++
640
641 Routine Description:
642
643 Used to allocate and build a device path node for a SCSI device
644 on a SCSI channel. Would not build device path for a SCSI Host Controller.
645
646 Arguments:
647
648 This - Protocol instance pointer.
649 Target - The Target ID of the SCSI device for which
650 a device path node is to be allocated and built.
651 Lun - The LUN of the SCSI device for which a device
652 path node is to be allocated and built.
653 DevicePath - A pointer to a single device path node that
654 describes the SCSI device specified by
655 Target and Lun. This function is responsible
656 for allocating the buffer DevicePath with the boot
657 service AllocatePool(). It is the caller's
658 responsibility to free DevicePath when the caller
659 is finished with DevicePath.
660 Returns:
661 EFI_SUCCESS - The device path node that describes the SCSI device
662 specified by Target and Lun was allocated and
663 returned in DevicePath.
664 EFI_NOT_FOUND - The SCSI devices specified by Target and Lun does
665 not exist on the SCSI channel.
666 EFI_INVALID_PARAMETER - DevicePath is NULL.
667 EFI_OUT_OF_RESOURCES - There are not enough resources to allocate
668 DevicePath.
669 --*/
670 {
671 EFI_DEV_PATH *Node;
672
673
674 //
675 // Validate parameters passed in.
676 //
677
678 if (DevicePath == NULL) {
679 return EFI_INVALID_PARAMETER;
680 }
681
682 //
683 // can not build device path for the SCSI Host Controller.
684 //
685 if ((Target > (MAX_TARGET_ID - 1)) || (Lun != 0)) {
686 return EFI_NOT_FOUND;
687 }
688
689 Node = AllocateZeroPool (sizeof (EFI_DEV_PATH));
690 if (Node == NULL) {
691 return EFI_OUT_OF_RESOURCES;
692 }
693
694 Node->DevPath.Type = MESSAGING_DEVICE_PATH;
695 Node->DevPath.SubType = MSG_ATAPI_DP;
696 SetDevicePathNodeLength (&Node->DevPath, sizeof (ATAPI_DEVICE_PATH));
697
698 Node->Atapi.PrimarySecondary = (UINT8) (Target / 2);
699 Node->Atapi.SlaveMaster = (UINT8) (Target % 2);
700 Node->Atapi.Lun = (UINT16) Lun;
701
702 *DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) Node;
703
704 return EFI_SUCCESS;
705 }
706
707 EFI_STATUS
708 EFIAPI
709 AtapiScsiPassThruGetTargetLun (
710 IN EFI_SCSI_PASS_THRU_PROTOCOL *This,
711 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
712 OUT UINT32 *Target,
713 OUT UINT64 *Lun
714 )
715 /*++
716
717 Routine Description:
718
719 Used to translate a device path node to a Target ID and LUN.
720
721 Arguments:
722
723 This - Protocol instance pointer.
724 DevicePath - A pointer to the device path node that
725 describes a SCSI device on the SCSI channel.
726 Target - A pointer to the Target ID of a SCSI device
727 on the SCSI channel.
728 Lun - A pointer to the LUN of a SCSI device on
729 the SCSI channel.
730 Returns:
731
732 EFI_SUCCESS - DevicePath was successfully translated to a
733 Target ID and LUN, and they were returned
734 in Target and Lun.
735 EFI_INVALID_PARAMETER - DevicePath/Target/Lun is NULL.
736 EFI_UNSUPPORTED - This driver does not support the device path
737 node type in DevicePath.
738 EFI_NOT_FOUND - A valid translation from DevicePath to a
739 Target ID and LUN does not exist.
740 --*/
741 {
742 EFI_DEV_PATH *Node;
743
744 //
745 // Validate parameters passed in.
746 //
747 if (DevicePath == NULL || Target == NULL || Lun == NULL) {
748 return EFI_INVALID_PARAMETER;
749 }
750
751 //
752 // Check whether the DevicePath belongs to SCSI_DEVICE_PATH
753 //
754 if ((DevicePath->Type != MESSAGING_DEVICE_PATH) ||
755 (DevicePath->SubType != MSG_ATAPI_DP) ||
756 (DevicePathNodeLength(DevicePath) != sizeof(ATAPI_DEVICE_PATH))) {
757 return EFI_UNSUPPORTED;
758 }
759
760 Node = (EFI_DEV_PATH *) DevicePath;
761
762 *Target = Node->Atapi.PrimarySecondary * 2 + Node->Atapi.SlaveMaster;
763 *Lun = Node->Atapi.Lun;
764
765 if (*Target > (MAX_TARGET_ID - 1) || *Lun != 0) {
766 return EFI_NOT_FOUND;
767 }
768
769 return EFI_SUCCESS;
770 }
771
772 EFI_STATUS
773 EFIAPI
774 AtapiScsiPassThruResetChannel (
775 IN EFI_SCSI_PASS_THRU_PROTOCOL *This
776 )
777 /*++
778
779 Routine Description:
780
781 Resets a SCSI channel.This operation resets all the
782 SCSI devices connected to the SCSI channel.
783
784 Arguments:
785
786 This - Protocol instance pointer.
787
788 Returns:
789
790 EFI_SUCCESS - The SCSI channel was reset.
791 EFI_UNSUPPORTED - The SCSI channel does not support
792 a channel reset operation.
793 EFI_DEVICE_ERROR - A device error occurred while
794 attempting to reset the SCSI channel.
795 EFI_TIMEOUT - A timeout occurred while attempting
796 to reset the SCSI channel.
797 --*/
798 {
799 UINT8 DeviceControlValue;
800 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate;
801 UINT8 Index;
802 BOOLEAN ResetFlag;
803
804 AtapiScsiPrivate = ATAPI_SCSI_PASS_THRU_DEV_FROM_THIS (This);
805 ResetFlag = FALSE;
806
807 //
808 // Reset both Primary channel and Secondary channel.
809 // so, the IoPort pointer must point to the right I/O Register group
810 //
811 for (Index = 0; Index < 2; Index++) {
812 //
813 // Reset
814 //
815 AtapiScsiPrivate->IoPort = &AtapiScsiPrivate->AtapiIoPortRegisters[Index];
816
817 DeviceControlValue = 0;
818 //
819 // set SRST bit to initiate soft reset
820 //
821 DeviceControlValue |= SRST;
822 //
823 // disable Interrupt
824 //
825 DeviceControlValue |= bit (1);
826 WritePortB (
827 AtapiScsiPrivate->PciIo,
828 AtapiScsiPrivate->IoPort->Alt.DeviceControl,
829 DeviceControlValue
830 );
831
832 //
833 // Wait 10us
834 //
835 gBS->Stall (10);
836
837 //
838 // Clear SRST bit
839 // 0xfb:1111,1011
840 //
841 DeviceControlValue &= 0xfb;
842
843 WritePortB (AtapiScsiPrivate->PciIo, AtapiScsiPrivate->IoPort->Alt.DeviceControl, DeviceControlValue);
844
845 //
846 // slave device needs at most 31s to clear BSY
847 //
848 if (StatusWaitForBSYClear (AtapiScsiPrivate, 31000000) != EFI_TIMEOUT) {
849 ResetFlag = TRUE;
850 }
851 }
852
853 if (ResetFlag) {
854 return EFI_SUCCESS;
855 }
856
857 return EFI_TIMEOUT;
858 }
859
860 EFI_STATUS
861 EFIAPI
862 AtapiScsiPassThruResetTarget (
863 IN EFI_SCSI_PASS_THRU_PROTOCOL *This,
864 IN UINT32 Target,
865 IN UINT64 Lun
866 )
867 /*++
868
869 Routine Description:
870
871 Resets a SCSI device that is connected to a SCSI channel.
872
873 Arguments:
874
875 This - Protocol instance pointer.
876 Target - The Target ID of the SCSI device to reset.
877 Lun - The LUN of the SCSI device to reset.
878
879 Returns:
880
881 EFI_SUCCESS - The SCSI device specified by Target and
882 Lun was reset.
883 EFI_UNSUPPORTED - The SCSI channel does not support a target
884 reset operation.
885 EFI_INVALID_PARAMETER - Target or Lun are invalid.
886 EFI_DEVICE_ERROR - A device error occurred while attempting
887 to reset the SCSI device specified by Target
888 and Lun.
889 EFI_TIMEOUT - A timeout occurred while attempting to reset
890 the SCSI device specified by Target and Lun.
891 --*/
892 {
893 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate;
894 UINT8 Command;
895 UINT8 DeviceSelect;
896
897 AtapiScsiPrivate = ATAPI_SCSI_PASS_THRU_DEV_FROM_THIS (This);
898
899 if ((Target > MAX_TARGET_ID) || (Lun != 0)) {
900 return EFI_INVALID_PARAMETER;
901 }
902 //
903 // Directly return EFI_SUCCESS if want to reset the host controller
904 //
905 if (Target == This->Mode->AdapterId) {
906 return EFI_SUCCESS;
907 }
908
909 //
910 // According to Target ID, reset the Atapi I/O Register mapping
911 // (Target Id in [0,1] area, using AtapiIoPortRegisters[0],
912 // Target Id in [2,3] area, using AtapiIoPortRegisters[1]
913 //
914 if ((Target / 2) == 0) {
915 AtapiScsiPrivate->IoPort = &AtapiScsiPrivate->AtapiIoPortRegisters[0];
916 } else {
917 AtapiScsiPrivate->IoPort = &AtapiScsiPrivate->AtapiIoPortRegisters[1];
918 }
919
920 //
921 // for ATAPI device, no need to wait DRDY ready after device selecting.
922 //
923 // bit7 and bit5 are both set to 1 for backward compatibility
924 //
925 DeviceSelect = (UINT8) (((bit (7) | bit (5)) | (Target << 4)));
926 WritePortB (AtapiScsiPrivate->PciIo, AtapiScsiPrivate->IoPort->Head, DeviceSelect);
927
928 Command = ATAPI_SOFT_RESET_CMD;
929 WritePortB (AtapiScsiPrivate->PciIo, AtapiScsiPrivate->IoPort->Reg.Command, Command);
930
931 //
932 // BSY clear is the only status return to the host by the device
933 // when reset is complete.
934 // slave device needs at most 31s to clear BSY
935 //
936 if (EFI_ERROR (StatusWaitForBSYClear (AtapiScsiPrivate, 31000000))) {
937 return EFI_TIMEOUT;
938 }
939
940 //
941 // stall 5 seconds to make the device status stable
942 //
943 gBS->Stall (5000000);
944
945 return EFI_SUCCESS;
946 }
947
948 EFI_STATUS
949 EFIAPI
950 AtapiExtScsiPassThruFunction (
951 IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This,
952 IN UINT8 *Target,
953 IN UINT64 Lun,
954 IN OUT EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet,
955 IN EFI_EVENT Event OPTIONAL
956 )
957 /*++
958
959 Routine Description:
960
961 Implements EFI_EXT_SCSI_PASS_THRU_PROTOCOL.PassThru() function.
962
963 Arguments:
964
965 This: The EFI_EXT_SCSI_PASS_THRU_PROTOCOL instance.
966 Target: The Target ID of the ATAPI device to send the SCSI
967 Request Packet. To ATAPI devices attached on an IDE
968 Channel, Target ID 0 indicates Master device;Target
969 ID 1 indicates Slave device.
970 Lun: The LUN of the ATAPI device to send the SCSI Request
971 Packet. To the ATAPI device, Lun is always 0.
972 Packet: The SCSI Request Packet to send to the ATAPI device
973 specified by Target and Lun.
974 Event: If non-blocking I/O is not supported then Event is ignored,
975 and blocking I/O is performed.
976 If Event is NULL, then blocking I/O is performed.
977 If Event is not NULL and non blocking I/O is supported,
978 then non-blocking I/O is performed, and Event will be signaled
979 when the SCSI Request Packet completes.
980
981 Returns:
982
983 EFI_STATUS
984
985 --*/
986 {
987 EFI_STATUS Status;
988 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate;
989 UINT8 TargetId;
990
991 AtapiScsiPrivate = ATAPI_EXT_SCSI_PASS_THRU_DEV_FROM_THIS (This);
992
993 //
994 // For ATAPI device, UINT8 is enough to represent the SCSI ID on channel.
995 //
996 TargetId = Target[0];
997
998 //
999 // Target is not allowed beyond MAX_TARGET_ID
1000 //
1001 if ((TargetId > MAX_TARGET_ID) || (Lun != 0)) {
1002 return EFI_INVALID_PARAMETER;
1003 }
1004
1005 //
1006 // check the data fields in Packet parameter.
1007 //
1008 Status = CheckExtSCSIRequestPacket (Packet);
1009 if (EFI_ERROR (Status)) {
1010 return Status;
1011 }
1012
1013 //
1014 // If Request Packet targets at the IDE channel itself,
1015 // do nothing.
1016 //
1017 if (TargetId == (UINT8)This->Mode->AdapterId) {
1018 Packet->InTransferLength = Packet->OutTransferLength = 0;
1019 return EFI_SUCCESS;
1020 }
1021
1022 //
1023 // According to Target ID, reset the Atapi I/O Register mapping
1024 // (Target Id in [0,1] area, using AtapiIoPortRegisters[0],
1025 // Target Id in [2,3] area, using AtapiIoPortRegisters[1]
1026 //
1027 if ((TargetId / 2) == 0) {
1028 TargetId = (UINT8) (TargetId % 2);
1029 AtapiScsiPrivate->IoPort = &AtapiScsiPrivate->AtapiIoPortRegisters[0];
1030 } else {
1031 TargetId = (UINT8) (TargetId % 2);
1032 AtapiScsiPrivate->IoPort = &AtapiScsiPrivate->AtapiIoPortRegisters[1];
1033 }
1034
1035 //
1036 // the ATAPI SCSI interface does not support non-blocking I/O
1037 // ignore the Event parameter
1038 //
1039 // Performs blocking I/O.
1040 //
1041 Status = SubmitExtBlockingIoCommand (AtapiScsiPrivate, TargetId, Packet);
1042 return Status;
1043 }
1044
1045 EFI_STATUS
1046 EFIAPI
1047 AtapiExtScsiPassThruGetNextTargetLun (
1048 IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This,
1049 IN OUT UINT8 **Target,
1050 IN OUT UINT64 *Lun
1051 )
1052 /*++
1053
1054 Routine Description:
1055
1056 Used to retrieve the list of legal Target IDs for SCSI devices
1057 on a SCSI channel.
1058
1059 Arguments:
1060
1061 This - Protocol instance pointer.
1062 Target - On input, a pointer to the Target ID of a SCSI
1063 device present on the SCSI channel. On output,
1064 a pointer to the Target ID of the next SCSI device
1065 present on a SCSI channel. An input value of
1066 0xFFFFFFFF retrieves the Target ID of the first
1067 SCSI device present on a SCSI channel.
1068 Lun - On input, a pointer to the LUN of a SCSI device
1069 present on the SCSI channel. On output, a pointer
1070 to the LUN of the next SCSI device present on
1071 a SCSI channel.
1072 Returns:
1073
1074 EFI_SUCCESS - The Target ID and Lun of the next SCSI device
1075 on the SCSI channel was returned in Target and Lun.
1076 EFI_NOT_FOUND - There are no more SCSI devices on this SCSI channel.
1077 EFI_INVALID_PARAMETER - Target is not 0xFFFFFFFF,and Target and Lun were not
1078 returned on a previous call to GetNextDevice().
1079 --*/
1080 {
1081 UINT8 ByteIndex;
1082 UINT8 TargetId;
1083 UINT8 ScsiId[TARGET_MAX_BYTES];
1084 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate;
1085
1086 //
1087 // Retrieve Device Private Data Structure.
1088 //
1089 AtapiScsiPrivate = ATAPI_EXT_SCSI_PASS_THRU_DEV_FROM_THIS (This);
1090
1091 //
1092 // Check whether Target is valid.
1093 //
1094 if (*Target == NULL || Lun == NULL) {
1095 return EFI_INVALID_PARAMETER;
1096 }
1097
1098 SetMem (ScsiId, TARGET_MAX_BYTES, 0xFF);
1099
1100 TargetId = (*Target)[0];
1101
1102 //
1103 // For ATAPI device, we use UINT8 to represent the SCSI ID on channel.
1104 //
1105 if (CompareMem(*Target, ScsiId, TARGET_MAX_BYTES) != 0) {
1106 for (ByteIndex = 1; ByteIndex < TARGET_MAX_BYTES; ByteIndex++) {
1107 if ((*Target)[ByteIndex] != 0) {
1108 return EFI_INVALID_PARAMETER;
1109 }
1110 }
1111 }
1112
1113 if ((CompareMem(*Target, ScsiId, TARGET_MAX_BYTES) != 0) &&
1114 ((TargetId != AtapiScsiPrivate->LatestTargetId) ||
1115 (*Lun != AtapiScsiPrivate->LatestLun))) {
1116 return EFI_INVALID_PARAMETER;
1117 }
1118
1119 if (TargetId == MAX_TARGET_ID) {
1120 return EFI_NOT_FOUND;
1121 }
1122
1123 if (CompareMem(*Target, ScsiId, TARGET_MAX_BYTES) == 0) {
1124 SetMem (*Target, TARGET_MAX_BYTES,0);
1125 } else {
1126 (*Target)[0] = (UINT8) (AtapiScsiPrivate->LatestTargetId + 1);
1127 }
1128
1129 *Lun = 0;
1130
1131 //
1132 // Update the LatestTargetId.
1133 //
1134 AtapiScsiPrivate->LatestTargetId = (*Target)[0];
1135 AtapiScsiPrivate->LatestLun = *Lun;
1136
1137 return EFI_SUCCESS;
1138
1139 }
1140
1141 EFI_STATUS
1142 EFIAPI
1143 AtapiExtScsiPassThruBuildDevicePath (
1144 IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This,
1145 IN UINT8 *Target,
1146 IN UINT64 Lun,
1147 IN OUT EFI_DEVICE_PATH_PROTOCOL **DevicePath
1148 )
1149 /*++
1150
1151 Routine Description:
1152
1153 Used to allocate and build a device path node for a SCSI device
1154 on a SCSI channel. Would not build device path for a SCSI Host Controller.
1155
1156 Arguments:
1157
1158 This - Protocol instance pointer.
1159 Target - The Target ID of the SCSI device for which
1160 a device path node is to be allocated and built.
1161 Lun - The LUN of the SCSI device for which a device
1162 path node is to be allocated and built.
1163 DevicePath - A pointer to a single device path node that
1164 describes the SCSI device specified by
1165 Target and Lun. This function is responsible
1166 for allocating the buffer DevicePath with the boot
1167 service AllocatePool(). It is the caller's
1168 responsibility to free DevicePath when the caller
1169 is finished with DevicePath.
1170 Returns:
1171 EFI_SUCCESS - The device path node that describes the SCSI device
1172 specified by Target and Lun was allocated and
1173 returned in DevicePath.
1174 EFI_NOT_FOUND - The SCSI devices specified by Target and Lun does
1175 not exist on the SCSI channel.
1176 EFI_INVALID_PARAMETER - DevicePath is NULL.
1177 EFI_OUT_OF_RESOURCES - There are not enough resources to allocate
1178 DevicePath.
1179 --*/
1180 {
1181 EFI_DEV_PATH *Node;
1182 UINT8 TargetId;
1183
1184 TargetId = Target[0];
1185
1186 //
1187 // Validate parameters passed in.
1188 //
1189
1190 if (DevicePath == NULL) {
1191 return EFI_INVALID_PARAMETER;
1192 }
1193
1194 //
1195 // can not build device path for the SCSI Host Controller.
1196 //
1197 if ((TargetId > (MAX_TARGET_ID - 1)) || (Lun != 0)) {
1198 return EFI_NOT_FOUND;
1199 }
1200
1201 Node = AllocateZeroPool (sizeof (EFI_DEV_PATH));
1202 if (Node == NULL) {
1203 return EFI_OUT_OF_RESOURCES;
1204 }
1205
1206 Node->DevPath.Type = MESSAGING_DEVICE_PATH;
1207 Node->DevPath.SubType = MSG_ATAPI_DP;
1208 SetDevicePathNodeLength (&Node->DevPath, sizeof (ATAPI_DEVICE_PATH));
1209
1210 Node->Atapi.PrimarySecondary = (UINT8) (TargetId / 2);
1211 Node->Atapi.SlaveMaster = (UINT8) (TargetId % 2);
1212 Node->Atapi.Lun = (UINT16) Lun;
1213
1214 *DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) Node;
1215
1216 return EFI_SUCCESS;
1217 }
1218
1219 EFI_STATUS
1220 EFIAPI
1221 AtapiExtScsiPassThruGetTargetLun (
1222 IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This,
1223 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
1224 OUT UINT8 **Target,
1225 OUT UINT64 *Lun
1226 )
1227 /*++
1228
1229 Routine Description:
1230
1231 Used to translate a device path node to a Target ID and LUN.
1232
1233 Arguments:
1234
1235 This - Protocol instance pointer.
1236 DevicePath - A pointer to the device path node that
1237 describes a SCSI device on the SCSI channel.
1238 Target - A pointer to the Target ID of a SCSI device
1239 on the SCSI channel.
1240 Lun - A pointer to the LUN of a SCSI device on
1241 the SCSI channel.
1242 Returns:
1243
1244 EFI_SUCCESS - DevicePath was successfully translated to a
1245 Target ID and LUN, and they were returned
1246 in Target and Lun.
1247 EFI_INVALID_PARAMETER - DevicePath/Target/Lun is NULL.
1248 EFI_UNSUPPORTED - This driver does not support the device path
1249 node type in DevicePath.
1250 EFI_NOT_FOUND - A valid translation from DevicePath to a
1251 Target ID and LUN does not exist.
1252 --*/
1253 {
1254 EFI_DEV_PATH *Node;
1255
1256 //
1257 // Validate parameters passed in.
1258 //
1259 if (DevicePath == NULL || Target == NULL || Lun == NULL) {
1260 return EFI_INVALID_PARAMETER;
1261 }
1262
1263 //
1264 // Check whether the DevicePath belongs to SCSI_DEVICE_PATH
1265 //
1266 if ((DevicePath->Type != MESSAGING_DEVICE_PATH) ||
1267 (DevicePath->SubType != MSG_ATAPI_DP) ||
1268 (DevicePathNodeLength(DevicePath) != sizeof(ATAPI_DEVICE_PATH))) {
1269 return EFI_UNSUPPORTED;
1270 }
1271
1272 ZeroMem (*Target, TARGET_MAX_BYTES);
1273
1274 Node = (EFI_DEV_PATH *) DevicePath;
1275
1276 (*Target)[0] = (UINT8) (Node->Atapi.PrimarySecondary * 2 + Node->Atapi.SlaveMaster);
1277 *Lun = Node->Atapi.Lun;
1278
1279 if ((*Target)[0] > (MAX_TARGET_ID - 1) || *Lun != 0) {
1280 return EFI_NOT_FOUND;
1281 }
1282
1283 return EFI_SUCCESS;
1284 }
1285
1286 EFI_STATUS
1287 EFIAPI
1288 AtapiExtScsiPassThruResetChannel (
1289 IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This
1290 )
1291 /*++
1292
1293 Routine Description:
1294
1295 Resets a SCSI channel.This operation resets all the
1296 SCSI devices connected to the SCSI channel.
1297
1298 Arguments:
1299
1300 This - Protocol instance pointer.
1301
1302 Returns:
1303
1304 EFI_SUCCESS - The SCSI channel was reset.
1305 EFI_UNSUPPORTED - The SCSI channel does not support
1306 a channel reset operation.
1307 EFI_DEVICE_ERROR - A device error occurred while
1308 attempting to reset the SCSI channel.
1309 EFI_TIMEOUT - A timeout occurred while attempting
1310 to reset the SCSI channel.
1311 --*/
1312 {
1313 UINT8 DeviceControlValue;
1314 UINT8 Index;
1315 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate;
1316 BOOLEAN ResetFlag;
1317
1318 AtapiScsiPrivate = ATAPI_EXT_SCSI_PASS_THRU_DEV_FROM_THIS (This);
1319 ResetFlag = FALSE;
1320 //
1321 // Reset both Primary channel and Secondary channel.
1322 // so, the IoPort pointer must point to the right I/O Register group
1323 // And if there is a channel reset successfully, return EFI_SUCCESS.
1324 //
1325 for (Index = 0; Index < 2; Index++) {
1326 //
1327 // Reset
1328 //
1329 AtapiScsiPrivate->IoPort = &AtapiScsiPrivate->AtapiIoPortRegisters[Index];
1330
1331 DeviceControlValue = 0;
1332 //
1333 // set SRST bit to initiate soft reset
1334 //
1335 DeviceControlValue |= SRST;
1336 //
1337 // disable Interrupt
1338 //
1339 DeviceControlValue |= bit (1);
1340 WritePortB (
1341 AtapiScsiPrivate->PciIo,
1342 AtapiScsiPrivate->IoPort->Alt.DeviceControl,
1343 DeviceControlValue
1344 );
1345
1346 //
1347 // Wait 10us
1348 //
1349 gBS->Stall (10);
1350
1351 //
1352 // Clear SRST bit
1353 // 0xfb:1111,1011
1354 //
1355 DeviceControlValue &= 0xfb;
1356
1357 WritePortB (AtapiScsiPrivate->PciIo, AtapiScsiPrivate->IoPort->Alt.DeviceControl, DeviceControlValue);
1358
1359 //
1360 // slave device needs at most 31s to clear BSY
1361 //
1362 if (StatusWaitForBSYClear (AtapiScsiPrivate, 31000000) != EFI_TIMEOUT) {
1363 ResetFlag = TRUE;
1364 }
1365 }
1366
1367 if (ResetFlag) {
1368 return EFI_SUCCESS;
1369 }
1370
1371 return EFI_TIMEOUT;
1372 }
1373
1374 EFI_STATUS
1375 EFIAPI
1376 AtapiExtScsiPassThruResetTarget (
1377 IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This,
1378 IN UINT8 *Target,
1379 IN UINT64 Lun
1380 )
1381 /*++
1382
1383 Routine Description:
1384
1385 Resets a SCSI device that is connected to a SCSI channel.
1386
1387 Arguments:
1388
1389 This - Protocol instance pointer.
1390 Target - The Target ID of the SCSI device to reset.
1391 Lun - The LUN of the SCSI device to reset.
1392
1393 Returns:
1394
1395 EFI_SUCCESS - The SCSI device specified by Target and
1396 Lun was reset.
1397 EFI_UNSUPPORTED - The SCSI channel does not support a target
1398 reset operation.
1399 EFI_INVALID_PARAMETER - Target or Lun are invalid.
1400 EFI_DEVICE_ERROR - A device error occurred while attempting
1401 to reset the SCSI device specified by Target
1402 and Lun.
1403 EFI_TIMEOUT - A timeout occurred while attempting to reset
1404 the SCSI device specified by Target and Lun.
1405 --*/
1406 {
1407 UINT8 Command;
1408 UINT8 DeviceSelect;
1409 UINT8 TargetId;
1410 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate;
1411
1412 AtapiScsiPrivate = ATAPI_EXT_SCSI_PASS_THRU_DEV_FROM_THIS (This);
1413 TargetId = Target[0];
1414
1415 if ((TargetId > MAX_TARGET_ID) || (Lun != 0)) {
1416 return EFI_INVALID_PARAMETER;
1417 }
1418 //
1419 // Directly return EFI_SUCCESS if want to reset the host controller
1420 //
1421 if (TargetId == This->Mode->AdapterId) {
1422 return EFI_SUCCESS;
1423 }
1424
1425 //
1426 // According to Target ID, reset the Atapi I/O Register mapping
1427 // (Target Id in [0,1] area, using AtapiIoPortRegisters[0],
1428 // Target Id in [2,3] area, using AtapiIoPortRegisters[1]
1429 //
1430 if ((TargetId / 2) == 0) {
1431 AtapiScsiPrivate->IoPort = &AtapiScsiPrivate->AtapiIoPortRegisters[0];
1432 } else {
1433 AtapiScsiPrivate->IoPort = &AtapiScsiPrivate->AtapiIoPortRegisters[1];
1434 }
1435
1436 //
1437 // for ATAPI device, no need to wait DRDY ready after device selecting.
1438 //
1439 // bit7 and bit5 are both set to 1 for backward compatibility
1440 //
1441 DeviceSelect = (UINT8) (((bit (7) | bit (5)) | (TargetId << 4)));
1442 WritePortB (AtapiScsiPrivate->PciIo, AtapiScsiPrivate->IoPort->Head, DeviceSelect);
1443
1444 Command = ATAPI_SOFT_RESET_CMD;
1445 WritePortB (AtapiScsiPrivate->PciIo, AtapiScsiPrivate->IoPort->Reg.Command, Command);
1446
1447 //
1448 // BSY clear is the only status return to the host by the device
1449 // when reset is complete.
1450 // slave device needs at most 31s to clear BSY
1451 //
1452 if (EFI_ERROR (StatusWaitForBSYClear (AtapiScsiPrivate, 31000000))) {
1453 return EFI_TIMEOUT;
1454 }
1455
1456 //
1457 // stall 5 seconds to make the device status stable
1458 //
1459 gBS->Stall (5000000);
1460
1461 return EFI_SUCCESS;
1462 }
1463
1464
1465 EFI_STATUS
1466 EFIAPI
1467 AtapiExtScsiPassThruGetNextTarget (
1468 IN EFI_EXT_SCSI_PASS_THRU_PROTOCOL *This,
1469 IN OUT UINT8 **Target
1470 )
1471 /*++
1472
1473 Routine Description:
1474 Used to retrieve the list of legal Target IDs for SCSI devices
1475 on a SCSI channel.
1476
1477 Arguments:
1478 This - Protocol instance pointer.
1479 Target - On input, a pointer to the Target ID of a SCSI
1480 device present on the SCSI channel. On output,
1481 a pointer to the Target ID of the next SCSI device
1482 present on a SCSI channel. An input value of
1483 0xFFFFFFFF retrieves the Target ID of the first
1484 SCSI device present on a SCSI channel.
1485 Lun - On input, a pointer to the LUN of a SCSI device
1486 present on the SCSI channel. On output, a pointer
1487 to the LUN of the next SCSI device present on
1488 a SCSI channel.
1489
1490 Returns:
1491 EFI_SUCCESS - The Target ID and Lun of the next SCSI device
1492 on the SCSI channel was returned in Target and Lun.
1493 EFI_NOT_FOUND - There are no more SCSI devices on this SCSI channel.
1494 EFI_INVALID_PARAMETER - Target is not 0xFFFFFFFF,and Target and Lun were not
1495 returned on a previous call to GetNextDevice().
1496 --*/
1497 {
1498 UINT8 TargetId;
1499 UINT8 ScsiId[TARGET_MAX_BYTES];
1500 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate;
1501 UINT8 ByteIndex;
1502
1503 //
1504 // Retrieve Device Private Data Structure.
1505 //
1506 AtapiScsiPrivate = ATAPI_EXT_SCSI_PASS_THRU_DEV_FROM_THIS (This);
1507
1508 //
1509 // Check whether Target is valid.
1510 //
1511 if (*Target == NULL ) {
1512 return EFI_INVALID_PARAMETER;
1513 }
1514
1515 TargetId = (*Target)[0];
1516 SetMem (ScsiId, TARGET_MAX_BYTES, 0xFF);
1517
1518 //
1519 // For ATAPI device, we use UINT8 to represent the SCSI ID on channel.
1520 //
1521 if (CompareMem(*Target, ScsiId, TARGET_MAX_BYTES) != 0) {
1522 for (ByteIndex = 1; ByteIndex < TARGET_MAX_BYTES; ByteIndex++) {
1523 if ((*Target)[ByteIndex] != 0) {
1524 return EFI_INVALID_PARAMETER;
1525 }
1526 }
1527 }
1528
1529 if ((CompareMem(*Target, ScsiId, TARGET_MAX_BYTES) != 0) &&(TargetId != AtapiScsiPrivate->LatestTargetId)) {
1530 return EFI_INVALID_PARAMETER;
1531 }
1532
1533 if (TargetId == MAX_TARGET_ID) {
1534 return EFI_NOT_FOUND;
1535 }
1536
1537 if ((CompareMem(*Target, ScsiId, TARGET_MAX_BYTES) == 0)) {
1538 SetMem (*Target, TARGET_MAX_BYTES, 0);
1539 } else {
1540 (*Target)[0] = (UINT8) (AtapiScsiPrivate->LatestTargetId + 1);
1541 }
1542
1543 //
1544 // Update the LatestTargetId.
1545 //
1546 AtapiScsiPrivate->LatestTargetId = (*Target)[0];
1547 AtapiScsiPrivate->LatestLun = 0;
1548
1549 return EFI_SUCCESS;
1550 }
1551
1552 EFI_STATUS
1553 GetIdeRegistersBaseAddr (
1554 IN EFI_PCI_IO_PROTOCOL *PciIo,
1555 OUT IDE_REGISTERS_BASE_ADDR *IdeRegsBaseAddr
1556 )
1557 /*++
1558
1559 Routine Description:
1560 Get IDE IO port registers' base addresses by mode. In 'Compatibility' mode,
1561 use fixed addresses. In Native-PCI mode, get base addresses from BARs in
1562 the PCI IDE controller's Configuration Space.
1563
1564 Arguments:
1565 PciIo - Pointer to the EFI_PCI_IO_PROTOCOL instance
1566 IdeRegsBaseAddr - Pointer to IDE_REGISTERS_BASE_ADDR to
1567 receive IDE IO port registers' base addresses
1568
1569 Returns:
1570
1571 EFI_STATUS
1572
1573 --*/
1574 {
1575 EFI_STATUS Status;
1576 PCI_TYPE00 PciData;
1577
1578 Status = PciIo->Pci.Read (
1579 PciIo,
1580 EfiPciIoWidthUint8,
1581 0,
1582 sizeof (PciData),
1583 &PciData
1584 );
1585
1586 if (EFI_ERROR (Status)) {
1587 return Status;
1588 }
1589
1590 if ((PciData.Hdr.ClassCode[0] & IDE_PRIMARY_OPERATING_MODE) == 0) {
1591 IdeRegsBaseAddr[IdePrimary].CommandBlockBaseAddr = 0x1f0;
1592 IdeRegsBaseAddr[IdePrimary].ControlBlockBaseAddr = 0x3f6;
1593 } else {
1594 //
1595 // The BARs should be of IO type
1596 //
1597 if ((PciData.Device.Bar[0] & BIT0) == 0 ||
1598 (PciData.Device.Bar[1] & BIT0) == 0) {
1599 return EFI_UNSUPPORTED;
1600 }
1601
1602 IdeRegsBaseAddr[IdePrimary].CommandBlockBaseAddr =
1603 (UINT16) (PciData.Device.Bar[0] & 0x0000fff8);
1604 IdeRegsBaseAddr[IdePrimary].ControlBlockBaseAddr =
1605 (UINT16) ((PciData.Device.Bar[1] & 0x0000fffc) + 2);
1606 }
1607
1608 if ((PciData.Hdr.ClassCode[0] & IDE_SECONDARY_OPERATING_MODE) == 0) {
1609 IdeRegsBaseAddr[IdeSecondary].CommandBlockBaseAddr = 0x170;
1610 IdeRegsBaseAddr[IdeSecondary].ControlBlockBaseAddr = 0x376;
1611 } else {
1612 //
1613 // The BARs should be of IO type
1614 //
1615 if ((PciData.Device.Bar[2] & BIT0) == 0 ||
1616 (PciData.Device.Bar[3] & BIT0) == 0) {
1617 return EFI_UNSUPPORTED;
1618 }
1619
1620 IdeRegsBaseAddr[IdeSecondary].CommandBlockBaseAddr =
1621 (UINT16) (PciData.Device.Bar[2] & 0x0000fff8);
1622 IdeRegsBaseAddr[IdeSecondary].ControlBlockBaseAddr =
1623 (UINT16) ((PciData.Device.Bar[3] & 0x0000fffc) + 2);
1624 }
1625
1626 return EFI_SUCCESS;
1627 }
1628
1629 VOID
1630 InitAtapiIoPortRegisters (
1631 IN ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
1632 IN IDE_REGISTERS_BASE_ADDR *IdeRegsBaseAddr
1633 )
1634 /*++
1635
1636 Routine Description:
1637
1638 Initialize each Channel's Base Address of CommandBlock and ControlBlock.
1639
1640 Arguments:
1641
1642 AtapiScsiPrivate - The pointer of ATAPI_SCSI_PASS_THRU_DEV
1643 IdeRegsBaseAddr - The pointer of IDE_REGISTERS_BASE_ADDR
1644
1645 Returns:
1646
1647 None
1648
1649 --*/
1650 {
1651
1652 UINT8 IdeChannel;
1653 UINT16 CommandBlockBaseAddr;
1654 UINT16 ControlBlockBaseAddr;
1655 IDE_BASE_REGISTERS *RegisterPointer;
1656
1657
1658 for (IdeChannel = 0; IdeChannel < ATAPI_MAX_CHANNEL; IdeChannel++) {
1659
1660 RegisterPointer = &AtapiScsiPrivate->AtapiIoPortRegisters[IdeChannel];
1661
1662 //
1663 // Initialize IDE IO port addresses, including Command Block registers
1664 // and Control Block registers
1665 //
1666 CommandBlockBaseAddr = IdeRegsBaseAddr[IdeChannel].CommandBlockBaseAddr;
1667 ControlBlockBaseAddr = IdeRegsBaseAddr[IdeChannel].ControlBlockBaseAddr;
1668
1669 RegisterPointer->Data = CommandBlockBaseAddr;
1670 (*(UINT16 *) &RegisterPointer->Reg1) = (UINT16) (CommandBlockBaseAddr + 0x01);
1671 RegisterPointer->SectorCount = (UINT16) (CommandBlockBaseAddr + 0x02);
1672 RegisterPointer->SectorNumber = (UINT16) (CommandBlockBaseAddr + 0x03);
1673 RegisterPointer->CylinderLsb = (UINT16) (CommandBlockBaseAddr + 0x04);
1674 RegisterPointer->CylinderMsb = (UINT16) (CommandBlockBaseAddr + 0x05);
1675 RegisterPointer->Head = (UINT16) (CommandBlockBaseAddr + 0x06);
1676 (*(UINT16 *) &RegisterPointer->Reg) = (UINT16) (CommandBlockBaseAddr + 0x07);
1677
1678 (*(UINT16 *) &RegisterPointer->Alt) = ControlBlockBaseAddr;
1679 RegisterPointer->DriveAddress = (UINT16) (ControlBlockBaseAddr + 0x01);
1680 }
1681
1682 }
1683
1684
1685 EFI_STATUS
1686 CheckSCSIRequestPacket (
1687 EFI_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet
1688 )
1689 /*++
1690
1691 Routine Description:
1692
1693 Checks the parameters in the SCSI Request Packet to make sure
1694 they are valid for a SCSI Pass Thru request.
1695
1696 Arguments:
1697
1698 Packet - The pointer of EFI_SCSI_PASS_THRU_SCSI_REQUEST_PACKET
1699
1700 Returns:
1701
1702 EFI_STATUS
1703
1704 --*/
1705 {
1706 if (Packet == NULL) {
1707 return EFI_INVALID_PARAMETER;
1708 }
1709
1710 if (!ValidCdbLength (Packet->CdbLength)) {
1711 return EFI_INVALID_PARAMETER;
1712 }
1713
1714 if (Packet->Cdb == NULL) {
1715 return EFI_INVALID_PARAMETER;
1716 }
1717
1718 //
1719 // Checks whether the request command is supported.
1720 //
1721 if (!IsCommandValid (Packet)) {
1722 return EFI_UNSUPPORTED;
1723 }
1724
1725 return EFI_SUCCESS;
1726 }
1727
1728 BOOLEAN
1729 IsCommandValid (
1730 EFI_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet
1731 )
1732 /*++
1733
1734 Routine Description:
1735
1736 Checks the requested SCSI command:
1737 Is it supported by this driver?
1738 Is the Data transfer direction reasonable?
1739
1740 Arguments:
1741
1742 Packet - The pointer of EFI_SCSI_PASS_THRU_SCSI_REQUEST_PACKET
1743
1744 Returns:
1745
1746 EFI_STATUS
1747
1748 --*/
1749 {
1750 UINT8 Index;
1751 UINT8 *OpCode;
1752
1753 OpCode = (UINT8 *) (Packet->Cdb);
1754
1755 for (Index = 0; CompareMem (&gSupportedATAPICommands[Index], &gEndTable, sizeof (SCSI_COMMAND_SET)); Index++) {
1756
1757 if (*OpCode == gSupportedATAPICommands[Index].OpCode) {
1758 //
1759 // Check whether the requested Command is supported by this driver
1760 //
1761 if (Packet->DataDirection == DataIn) {
1762 //
1763 // Check whether the requested data direction conforms to
1764 // what it should be.
1765 //
1766 if (gSupportedATAPICommands[Index].Direction == DataOut) {
1767 return FALSE;
1768 }
1769 }
1770
1771 if (Packet->DataDirection == DataOut) {
1772 //
1773 // Check whether the requested data direction conforms to
1774 // what it should be.
1775 //
1776 if (gSupportedATAPICommands[Index].Direction == DataIn) {
1777 return FALSE;
1778 }
1779 }
1780
1781 return TRUE;
1782 }
1783 }
1784
1785 return FALSE;
1786 }
1787
1788 EFI_STATUS
1789 SubmitBlockingIoCommand (
1790 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
1791 UINT32 Target,
1792 EFI_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet
1793 )
1794 /*++
1795
1796 Routine Description:
1797
1798 Performs blocking I/O request.
1799
1800 Arguments:
1801
1802 AtapiScsiPrivate: Private data structure for the specified channel.
1803 Target: The Target ID of the ATAPI device to send the SCSI
1804 Request Packet. To ATAPI devices attached on an IDE
1805 Channel, Target ID 0 indicates Master device;Target
1806 ID 1 indicates Slave device.
1807 Packet: The SCSI Request Packet to send to the ATAPI device
1808 specified by Target.
1809
1810 Returns: EFI_STATUS
1811
1812 --*/
1813 {
1814 UINT8 PacketCommand[12];
1815 UINT64 TimeoutInMicroSeconds;
1816 EFI_STATUS PacketCommandStatus;
1817
1818 //
1819 // Fill ATAPI Command Packet according to CDB
1820 //
1821 ZeroMem (&PacketCommand, 12);
1822 CopyMem (&PacketCommand, Packet->Cdb, Packet->CdbLength);
1823
1824 //
1825 // Timeout is 100ns unit, convert it to 1000ns (1us) unit.
1826 //
1827 TimeoutInMicroSeconds = DivU64x32 (Packet->Timeout, (UINT32) 10);
1828
1829 //
1830 // Submit ATAPI Command Packet
1831 //
1832 PacketCommandStatus = AtapiPacketCommand (
1833 AtapiScsiPrivate,
1834 Target,
1835 PacketCommand,
1836 Packet->DataBuffer,
1837 &(Packet->TransferLength),
1838 (DATA_DIRECTION) Packet->DataDirection,
1839 TimeoutInMicroSeconds
1840 );
1841 if (!EFI_ERROR (PacketCommandStatus) || (Packet->SenseData == NULL)) {
1842 Packet->SenseDataLength = 0;
1843 return PacketCommandStatus;
1844 }
1845
1846 //
1847 // Return SenseData if PacketCommandStatus matches
1848 // the following return codes.
1849 //
1850 if ((PacketCommandStatus == EFI_BAD_BUFFER_SIZE) ||
1851 (PacketCommandStatus == EFI_DEVICE_ERROR) ||
1852 (PacketCommandStatus == EFI_TIMEOUT)) {
1853
1854 //
1855 // avoid submit request sense command continuously.
1856 //
1857 if (PacketCommand[0] == OP_REQUEST_SENSE) {
1858 Packet->SenseDataLength = 0;
1859 return PacketCommandStatus;
1860 }
1861
1862 RequestSenseCommand (
1863 AtapiScsiPrivate,
1864 Target,
1865 Packet->Timeout,
1866 Packet->SenseData,
1867 &Packet->SenseDataLength
1868 );
1869 }
1870
1871 return PacketCommandStatus;
1872 }
1873
1874 EFI_STATUS
1875 RequestSenseCommand (
1876 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
1877 UINT32 Target,
1878 UINT64 Timeout,
1879 VOID *SenseData,
1880 UINT8 *SenseDataLength
1881 )
1882 /*++
1883
1884 Routine Description:
1885
1886 Sumbit request sense command
1887
1888 Arguments:
1889
1890 AtapiScsiPrivate - The pionter of ATAPI_SCSI_PASS_THRU_DEV
1891 Target - The target ID
1892 Timeout - The time to complete the command
1893 SenseData - The buffer to fill in sense data
1894 SenseDataLength - The length of buffer
1895
1896 Returns:
1897
1898 EFI_STATUS
1899
1900 --*/
1901 {
1902 EFI_SCSI_PASS_THRU_SCSI_REQUEST_PACKET Packet;
1903 UINT8 Cdb[12];
1904 EFI_STATUS Status;
1905
1906 ZeroMem (&Packet, sizeof (EFI_SCSI_PASS_THRU_SCSI_REQUEST_PACKET));
1907 ZeroMem (Cdb, 12);
1908
1909 Cdb[0] = OP_REQUEST_SENSE;
1910 Cdb[4] = (UINT8) (*SenseDataLength);
1911
1912 Packet.Timeout = Timeout;
1913 Packet.DataBuffer = SenseData;
1914 Packet.SenseData = NULL;
1915 Packet.Cdb = Cdb;
1916 Packet.TransferLength = *SenseDataLength;
1917 Packet.CdbLength = 12;
1918 Packet.DataDirection = DataIn;
1919
1920 Status = SubmitBlockingIoCommand (AtapiScsiPrivate, Target, &Packet);
1921 *SenseDataLength = (UINT8) (Packet.TransferLength);
1922 return Status;
1923 }
1924
1925 EFI_STATUS
1926 CheckExtSCSIRequestPacket (
1927 EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet
1928 )
1929 /*++
1930
1931 Routine Description:
1932
1933 Checks the parameters in the SCSI Request Packet to make sure
1934 they are valid for a SCSI Pass Thru request.
1935
1936 Arguments:
1937
1938 Packet - The pointer of EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET
1939
1940 Returns:
1941
1942 EFI_STATUS
1943
1944 --*/
1945 {
1946 if (Packet == NULL) {
1947 return EFI_INVALID_PARAMETER;
1948 }
1949
1950 if (!ValidCdbLength (Packet->CdbLength)) {
1951 return EFI_INVALID_PARAMETER;
1952 }
1953
1954 if (Packet->Cdb == NULL) {
1955 return EFI_INVALID_PARAMETER;
1956 }
1957
1958 //
1959 // Checks whether the request command is supported.
1960 //
1961 if (!IsExtCommandValid (Packet)) {
1962 return EFI_UNSUPPORTED;
1963 }
1964
1965 return EFI_SUCCESS;
1966 }
1967
1968
1969 BOOLEAN
1970 IsExtCommandValid (
1971 EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet
1972 )
1973 /*++
1974
1975 Routine Description:
1976
1977 Checks the requested SCSI command:
1978 Is it supported by this driver?
1979 Is the Data transfer direction reasonable?
1980
1981 Arguments:
1982
1983 Packet - The pointer of EFI_SCSI_PASS_THRU_SCSI_REQUEST_PACKET
1984
1985 Returns:
1986
1987 EFI_STATUS
1988
1989 --*/
1990 {
1991 UINT8 Index;
1992 UINT8 *OpCode;
1993
1994 OpCode = (UINT8 *) (Packet->Cdb);
1995
1996 for (Index = 0; CompareMem (&gSupportedATAPICommands[Index], &gEndTable, sizeof (SCSI_COMMAND_SET)); Index++) {
1997
1998 if (*OpCode == gSupportedATAPICommands[Index].OpCode) {
1999 //
2000 // Check whether the requested Command is supported by this driver
2001 //
2002 if (Packet->DataDirection == DataIn) {
2003 //
2004 // Check whether the requested data direction conforms to
2005 // what it should be.
2006 //
2007 if (gSupportedATAPICommands[Index].Direction == DataOut) {
2008 return FALSE;
2009 }
2010 }
2011
2012 if (Packet->DataDirection == DataOut) {
2013 //
2014 // Check whether the requested data direction conforms to
2015 // what it should be.
2016 //
2017 if (gSupportedATAPICommands[Index].Direction == DataIn) {
2018 return FALSE;
2019 }
2020 }
2021
2022 return TRUE;
2023 }
2024 }
2025
2026 return FALSE;
2027 }
2028
2029 EFI_STATUS
2030 SubmitExtBlockingIoCommand (
2031 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
2032 UINT8 Target,
2033 EFI_EXT_SCSI_PASS_THRU_SCSI_REQUEST_PACKET *Packet
2034 )
2035 /*++
2036
2037 Routine Description:
2038
2039 Performs blocking I/O request.
2040
2041 Arguments:
2042
2043 AtapiScsiPrivate: Private data structure for the specified channel.
2044 Target: The Target ID of the ATAPI device to send the SCSI
2045 Request Packet. To ATAPI devices attached on an IDE
2046 Channel, Target ID 0 indicates Master device;Target
2047 ID 1 indicates Slave device.
2048 Packet: The SCSI Request Packet to send to the ATAPI device
2049 specified by Target.
2050
2051 Returns: EFI_STATUS
2052
2053 --*/
2054 {
2055 UINT8 PacketCommand[12];
2056 UINT64 TimeoutInMicroSeconds;
2057 EFI_STATUS PacketCommandStatus;
2058
2059 //
2060 // Fill ATAPI Command Packet according to CDB
2061 //
2062 ZeroMem (&PacketCommand, 12);
2063 CopyMem (&PacketCommand, Packet->Cdb, Packet->CdbLength);
2064
2065 //
2066 // Timeout is 100ns unit, convert it to 1000ns (1us) unit.
2067 //
2068 TimeoutInMicroSeconds = DivU64x32 (Packet->Timeout, (UINT32) 10);
2069
2070 //
2071 // Submit ATAPI Command Packet
2072 //
2073 if (Packet->DataDirection == DataIn) {
2074 PacketCommandStatus = AtapiPacketCommand (
2075 AtapiScsiPrivate,
2076 Target,
2077 PacketCommand,
2078 Packet->InDataBuffer,
2079 &(Packet->InTransferLength),
2080 DataIn,
2081 TimeoutInMicroSeconds
2082 );
2083 } else {
2084
2085 PacketCommandStatus = AtapiPacketCommand (
2086 AtapiScsiPrivate,
2087 Target,
2088 PacketCommand,
2089 Packet->OutDataBuffer,
2090 &(Packet->OutTransferLength),
2091 DataOut,
2092 TimeoutInMicroSeconds
2093 );
2094 }
2095
2096 if (!EFI_ERROR (PacketCommandStatus) || (Packet->SenseData == NULL)) {
2097 Packet->SenseDataLength = 0;
2098 return PacketCommandStatus;
2099 }
2100
2101 //
2102 // Return SenseData if PacketCommandStatus matches
2103 // the following return codes.
2104 //
2105 if ((PacketCommandStatus == EFI_BAD_BUFFER_SIZE) ||
2106 (PacketCommandStatus == EFI_DEVICE_ERROR) ||
2107 (PacketCommandStatus == EFI_TIMEOUT)) {
2108
2109 //
2110 // avoid submit request sense command continuously.
2111 //
2112 if (PacketCommand[0] == OP_REQUEST_SENSE) {
2113 Packet->SenseDataLength = 0;
2114 return PacketCommandStatus;
2115 }
2116
2117 RequestSenseCommand (
2118 AtapiScsiPrivate,
2119 Target,
2120 Packet->Timeout,
2121 Packet->SenseData,
2122 &Packet->SenseDataLength
2123 );
2124 }
2125
2126 return PacketCommandStatus;
2127 }
2128
2129
2130 EFI_STATUS
2131 AtapiPacketCommand (
2132 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
2133 UINT32 Target,
2134 UINT8 *PacketCommand,
2135 VOID *Buffer,
2136 UINT32 *ByteCount,
2137 DATA_DIRECTION Direction,
2138 UINT64 TimeoutInMicroSeconds
2139 )
2140 /*++
2141
2142 Routine Description:
2143
2144 Submits ATAPI command packet to the specified ATAPI device.
2145
2146 Arguments:
2147
2148 AtapiScsiPrivate: Private data structure for the specified channel.
2149 Target: The Target ID of the ATAPI device to send the SCSI
2150 Request Packet. To ATAPI devices attached on an IDE
2151 Channel, Target ID 0 indicates Master device;Target
2152 ID 1 indicates Slave device.
2153 PacketCommand: Points to the ATAPI command packet.
2154 Buffer: Points to the transferred data.
2155 ByteCount: When input,indicates the buffer size; when output,
2156 indicates the actually transferred data size.
2157 Direction: Indicates the data transfer direction.
2158 TimeoutInMicroSeconds:
2159 The timeout, in micro second units, to use for the
2160 execution of this ATAPI command.
2161 A TimeoutInMicroSeconds value of 0 means that
2162 this function will wait indefinitely for the ATAPI
2163 command to execute.
2164 If TimeoutInMicroSeconds is greater than zero, then
2165 this function will return EFI_TIMEOUT if the time
2166 required to execute the ATAPI command is greater
2167 than TimeoutInMicroSeconds.
2168
2169 Returns:
2170
2171 EFI_STATUS
2172
2173 --*/
2174 {
2175
2176 UINT16 *CommandIndex;
2177 UINT8 Count;
2178 EFI_STATUS Status;
2179
2180 //
2181 // Set all the command parameters by fill related registers.
2182 // Before write to all the following registers, BSY must be 0.
2183 //
2184 Status = StatusWaitForBSYClear (AtapiScsiPrivate, TimeoutInMicroSeconds);
2185 if (EFI_ERROR (Status)) {
2186 return EFI_DEVICE_ERROR;
2187 }
2188
2189
2190 //
2191 // Select device via Device/Head Register.
2192 // "Target = 0" indicates device 0; "Target = 1" indicates device 1
2193 //
2194 WritePortB (
2195 AtapiScsiPrivate->PciIo,
2196 AtapiScsiPrivate->IoPort->Head,
2197 (UINT8) ((Target << 4) | DEFAULT_CMD) // DEFAULT_CMD: 0xa0 (1010,0000)
2198 );
2199
2200 //
2201 // Set all the command parameters by fill related registers.
2202 // Before write to all the following registers, BSY DRQ must be 0.
2203 //
2204 Status = StatusDRQClear(AtapiScsiPrivate, TimeoutInMicroSeconds);
2205
2206 if (EFI_ERROR (Status)) {
2207 if (Status == EFI_ABORTED) {
2208 Status = EFI_DEVICE_ERROR;
2209 }
2210 *ByteCount = 0;
2211 return Status;
2212 }
2213
2214 //
2215 // No OVL; No DMA (by setting feature register)
2216 //
2217 WritePortB (
2218 AtapiScsiPrivate->PciIo,
2219 AtapiScsiPrivate->IoPort->Reg1.Feature,
2220 0x00
2221 );
2222
2223 //
2224 // set the transfersize to MAX_ATAPI_BYTE_COUNT to let the device
2225 // determine how much data should be transfered.
2226 //
2227 WritePortB (
2228 AtapiScsiPrivate->PciIo,
2229 AtapiScsiPrivate->IoPort->CylinderLsb,
2230 (UINT8) (MAX_ATAPI_BYTE_COUNT & 0x00ff)
2231 );
2232 WritePortB (
2233 AtapiScsiPrivate->PciIo,
2234 AtapiScsiPrivate->IoPort->CylinderMsb,
2235 (UINT8) (MAX_ATAPI_BYTE_COUNT >> 8)
2236 );
2237
2238 //
2239 // DEFAULT_CTL:0x0a (0000,1010)
2240 // Disable interrupt
2241 //
2242 WritePortB (
2243 AtapiScsiPrivate->PciIo,
2244 AtapiScsiPrivate->IoPort->Alt.DeviceControl,
2245 DEFAULT_CTL
2246 );
2247
2248 //
2249 // Send Packet command to inform device
2250 // that the following data bytes are command packet.
2251 //
2252 WritePortB (
2253 AtapiScsiPrivate->PciIo,
2254 AtapiScsiPrivate->IoPort->Reg.Command,
2255 PACKET_CMD
2256 );
2257
2258 //
2259 // Before data transfer, BSY should be 0 and DRQ should be 1.
2260 // if they are not in specified time frame,
2261 // retrieve Sense Key from Error Register before return.
2262 //
2263 Status = StatusDRQReady (AtapiScsiPrivate, TimeoutInMicroSeconds);
2264 if (EFI_ERROR (Status)) {
2265 if (Status == EFI_ABORTED) {
2266 Status = EFI_DEVICE_ERROR;
2267 }
2268
2269 *ByteCount = 0;
2270 return Status;
2271 }
2272
2273 //
2274 // Send out command packet
2275 //
2276 CommandIndex = (UINT16 *) PacketCommand;
2277 for (Count = 0; Count < 6; Count++, CommandIndex++) {
2278 WritePortW (AtapiScsiPrivate->PciIo, AtapiScsiPrivate->IoPort->Data, *CommandIndex);
2279 }
2280
2281 //
2282 // call AtapiPassThruPioReadWriteData() function to get
2283 // requested transfer data form device.
2284 //
2285 return AtapiPassThruPioReadWriteData (
2286 AtapiScsiPrivate,
2287 Buffer,
2288 ByteCount,
2289 Direction,
2290 TimeoutInMicroSeconds
2291 );
2292 }
2293
2294 EFI_STATUS
2295 AtapiPassThruPioReadWriteData (
2296 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
2297 UINT16 *Buffer,
2298 UINT32 *ByteCount,
2299 DATA_DIRECTION Direction,
2300 UINT64 TimeoutInMicroSeconds
2301 )
2302 /*++
2303
2304 Routine Description:
2305
2306 Performs data transfer between ATAPI device and host after the
2307 ATAPI command packet is sent.
2308
2309 Arguments:
2310
2311 AtapiScsiPrivate: Private data structure for the specified channel.
2312 Buffer: Points to the transferred data.
2313 ByteCount: When input,indicates the buffer size; when output,
2314 indicates the actually transferred data size.
2315 Direction: Indicates the data transfer direction.
2316 TimeoutInMicroSeconds:
2317 The timeout, in micro second units, to use for the
2318 execution of this ATAPI command.
2319 A TimeoutInMicroSeconds value of 0 means that
2320 this function will wait indefinitely for the ATAPI
2321 command to execute.
2322 If TimeoutInMicroSeconds is greater than zero, then
2323 this function will return EFI_TIMEOUT if the time
2324 required to execute the ATAPI command is greater
2325 than TimeoutInMicroSeconds.
2326 Returns:
2327
2328 EFI_STATUS
2329
2330 --*/
2331 {
2332 UINT32 Index;
2333 UINT32 RequiredWordCount;
2334 UINT32 ActualWordCount;
2335 UINT32 WordCount;
2336 EFI_STATUS Status;
2337 UINT16 *ptrBuffer;
2338
2339 Status = EFI_SUCCESS;
2340
2341 //
2342 // Non Data transfer request is also supported.
2343 //
2344 if (*ByteCount == 0 || Buffer == NULL) {
2345 *ByteCount = 0;
2346 if (EFI_ERROR (StatusWaitForBSYClear (AtapiScsiPrivate, TimeoutInMicroSeconds))) {
2347 return EFI_DEVICE_ERROR;
2348 }
2349 }
2350
2351 ptrBuffer = Buffer;
2352 RequiredWordCount = *ByteCount / 2;
2353
2354 //
2355 // ActuralWordCount means the word count of data really transfered.
2356 //
2357 ActualWordCount = 0;
2358
2359 while (ActualWordCount < RequiredWordCount) {
2360 //
2361 // before each data transfer stream, the host should poll DRQ bit ready,
2362 // which indicates device's ready for data transfer .
2363 //
2364 Status = StatusDRQReady (AtapiScsiPrivate, TimeoutInMicroSeconds);
2365 if (EFI_ERROR (Status)) {
2366 *ByteCount = ActualWordCount * 2;
2367
2368 AtapiPassThruCheckErrorStatus (AtapiScsiPrivate);
2369
2370 if (ActualWordCount == 0) {
2371 return EFI_DEVICE_ERROR;
2372 }
2373 //
2374 // ActualWordCount > 0
2375 //
2376 if (ActualWordCount < RequiredWordCount) {
2377 return EFI_BAD_BUFFER_SIZE;
2378 }
2379 }
2380 //
2381 // get current data transfer size from Cylinder Registers.
2382 //
2383 WordCount = ReadPortB (AtapiScsiPrivate->PciIo, AtapiScsiPrivate->IoPort->CylinderMsb) << 8;
2384 WordCount = WordCount | ReadPortB (AtapiScsiPrivate->PciIo, AtapiScsiPrivate->IoPort->CylinderLsb);
2385 WordCount = WordCount & 0xffff;
2386 WordCount /= 2;
2387
2388 //
2389 // perform a series data In/Out.
2390 //
2391 for (Index = 0; (Index < WordCount) && (ActualWordCount < RequiredWordCount); Index++, ActualWordCount++) {
2392
2393 if (Direction == DataIn) {
2394
2395 *ptrBuffer = ReadPortW (AtapiScsiPrivate->PciIo, AtapiScsiPrivate->IoPort->Data);
2396 } else {
2397
2398 WritePortW (AtapiScsiPrivate->PciIo, AtapiScsiPrivate->IoPort->Data, *ptrBuffer);
2399 }
2400
2401 ptrBuffer++;
2402
2403 }
2404 }
2405 //
2406 // After data transfer is completed, normally, DRQ bit should clear.
2407 //
2408 StatusDRQClear (AtapiScsiPrivate, TimeoutInMicroSeconds);
2409
2410 //
2411 // read status register to check whether error happens.
2412 //
2413 Status = AtapiPassThruCheckErrorStatus (AtapiScsiPrivate);
2414
2415 *ByteCount = ActualWordCount * 2;
2416
2417 return Status;
2418 }
2419
2420
2421 UINT8
2422 ReadPortB (
2423 IN EFI_PCI_IO_PROTOCOL *PciIo,
2424 IN UINT16 Port
2425 )
2426 /*++
2427
2428 Routine Description:
2429
2430 Read one byte from a specified I/O port.
2431
2432 Arguments:
2433
2434 PciIo - The pointer of EFI_PCI_IO_PROTOCOL
2435 Port - IO port
2436
2437 Returns:
2438
2439 A byte read out
2440
2441 --*/
2442 {
2443 UINT8 Data;
2444
2445 Data = 0;
2446 PciIo->Io.Read (
2447 PciIo,
2448 EfiPciIoWidthUint8,
2449 EFI_PCI_IO_PASS_THROUGH_BAR,
2450 (UINT64) Port,
2451 1,
2452 &Data
2453 );
2454 return Data;
2455 }
2456
2457
2458 UINT16
2459 ReadPortW (
2460 IN EFI_PCI_IO_PROTOCOL *PciIo,
2461 IN UINT16 Port
2462 )
2463 /*++
2464
2465 Routine Description:
2466
2467 Read one word from a specified I/O port.
2468
2469 Arguments:
2470
2471 PciIo - The pointer of EFI_PCI_IO_PROTOCOL
2472 Port - IO port
2473
2474 Returns:
2475
2476 A word read out
2477 --*/
2478 {
2479 UINT16 Data;
2480
2481 Data = 0;
2482 PciIo->Io.Read (
2483 PciIo,
2484 EfiPciIoWidthUint16,
2485 EFI_PCI_IO_PASS_THROUGH_BAR,
2486 (UINT64) Port,
2487 1,
2488 &Data
2489 );
2490 return Data;
2491 }
2492
2493
2494 VOID
2495 WritePortB (
2496 IN EFI_PCI_IO_PROTOCOL *PciIo,
2497 IN UINT16 Port,
2498 IN UINT8 Data
2499 )
2500 /*++
2501
2502 Routine Description:
2503
2504 Write one byte to a specified I/O port.
2505
2506 Arguments:
2507
2508 PciIo - The pointer of EFI_PCI_IO_PROTOCOL
2509 Port - IO port
2510 Data - The data to write
2511
2512 Returns:
2513
2514 NONE
2515
2516 --*/
2517 {
2518 PciIo->Io.Write (
2519 PciIo,
2520 EfiPciIoWidthUint8,
2521 EFI_PCI_IO_PASS_THROUGH_BAR,
2522 (UINT64) Port,
2523 1,
2524 &Data
2525 );
2526 }
2527
2528
2529 VOID
2530 WritePortW (
2531 IN EFI_PCI_IO_PROTOCOL *PciIo,
2532 IN UINT16 Port,
2533 IN UINT16 Data
2534 )
2535 /*++
2536
2537 Routine Description:
2538
2539 Write one word to a specified I/O port.
2540
2541 Arguments:
2542
2543 PciIo - The pointer of EFI_PCI_IO_PROTOCOL
2544 Port - IO port
2545 Data - The data to write
2546
2547 Returns:
2548
2549 NONE
2550
2551 --*/
2552 {
2553 PciIo->Io.Write (
2554 PciIo,
2555 EfiPciIoWidthUint16,
2556 EFI_PCI_IO_PASS_THROUGH_BAR,
2557 (UINT64) Port,
2558 1,
2559 &Data
2560 );
2561 }
2562
2563 EFI_STATUS
2564 StatusDRQClear (
2565 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
2566 UINT64 TimeoutInMicroSeconds
2567 )
2568 /*++
2569
2570 Routine Description:
2571
2572 Check whether DRQ is clear in the Status Register. (BSY must also be cleared)
2573 If TimeoutInMicroSeconds is zero, this routine should wait infinitely for
2574 DRQ clear. Otherwise, it will return EFI_TIMEOUT when specified time is
2575 elapsed.
2576
2577 Arguments:
2578
2579 AtapiScsiPrivate - The pointer of ATAPI_SCSI_PASS_THRU_DEV
2580 TimeoutInMicroSeconds - The time to wait for
2581
2582 Returns:
2583
2584 EFI_STATUS
2585
2586 --*/
2587 {
2588 UINT64 Delay;
2589 UINT8 StatusRegister;
2590 UINT8 ErrRegister;
2591
2592 if (TimeoutInMicroSeconds == 0) {
2593 Delay = 2;
2594 } else {
2595 Delay = DivU64x32 (TimeoutInMicroSeconds, (UINT32) 30) + 1;
2596 }
2597
2598 do {
2599
2600 StatusRegister = ReadPortB (
2601 AtapiScsiPrivate->PciIo,
2602 AtapiScsiPrivate->IoPort->Reg.Status
2603 );
2604
2605 //
2606 // wait for BSY == 0 and DRQ == 0
2607 //
2608 if ((StatusRegister & (DRQ | BSY)) == 0) {
2609 break;
2610 }
2611 //
2612 // check whether the command is aborted by the device
2613 //
2614 if ((StatusRegister & (BSY | ERR)) == ERR) {
2615
2616 ErrRegister = ReadPortB (
2617 AtapiScsiPrivate->PciIo,
2618 AtapiScsiPrivate->IoPort->Reg1.Error
2619 );
2620 if ((ErrRegister & ABRT_ERR) == ABRT_ERR) {
2621
2622 return EFI_ABORTED;
2623 }
2624 }
2625 //
2626 // Stall for 30 us
2627 //
2628 gBS->Stall (30);
2629
2630 //
2631 // Loop infinitely if not meeting expected condition
2632 //
2633 if (TimeoutInMicroSeconds == 0) {
2634 Delay = 2;
2635 }
2636
2637 Delay--;
2638 } while (Delay);
2639
2640 if (Delay == 0) {
2641 return EFI_TIMEOUT;
2642 }
2643
2644 return EFI_SUCCESS;
2645 }
2646
2647 EFI_STATUS
2648 AltStatusDRQClear (
2649 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
2650 UINT64 TimeoutInMicroSeconds
2651 )
2652 /*++
2653
2654 Routine Description:
2655
2656 Check whether DRQ is clear in the Alternate Status Register.
2657 (BSY must also be cleared).If TimeoutInMicroSeconds is zero, this routine should
2658 wait infinitely for DRQ clear. Otherwise, it will return EFI_TIMEOUT when specified time is
2659 elapsed.
2660
2661 Arguments:
2662
2663 AtapiScsiPrivate - The pointer of ATAPI_SCSI_PASS_THRU_DEV
2664 TimeoutInMicroSeconds - The time to wait for
2665
2666 Returns:
2667
2668 EFI_STATUS
2669
2670 --*/
2671 {
2672 UINT64 Delay;
2673 UINT8 AltStatusRegister;
2674 UINT8 ErrRegister;
2675
2676 if (TimeoutInMicroSeconds == 0) {
2677 Delay = 2;
2678 } else {
2679 Delay = DivU64x32 (TimeoutInMicroSeconds, (UINT32) 30) + 1;
2680 }
2681
2682 do {
2683
2684 AltStatusRegister = ReadPortB (
2685 AtapiScsiPrivate->PciIo,
2686 AtapiScsiPrivate->IoPort->Alt.AltStatus
2687 );
2688
2689 //
2690 // wait for BSY == 0 and DRQ == 0
2691 //
2692 if ((AltStatusRegister & (DRQ | BSY)) == 0) {
2693 break;
2694 }
2695
2696 if ((AltStatusRegister & (BSY | ERR)) == ERR) {
2697
2698 ErrRegister = ReadPortB (
2699 AtapiScsiPrivate->PciIo,
2700 AtapiScsiPrivate->IoPort->Reg1.Error
2701 );
2702 if ((ErrRegister & ABRT_ERR) == ABRT_ERR) {
2703
2704 return EFI_ABORTED;
2705 }
2706 }
2707 //
2708 // Stall for 30 us
2709 //
2710 gBS->Stall (30);
2711
2712 //
2713 // Loop infinitely if not meeting expected condition
2714 //
2715 if (TimeoutInMicroSeconds == 0) {
2716 Delay = 2;
2717 }
2718
2719 Delay--;
2720 } while (Delay);
2721
2722 if (Delay == 0) {
2723 return EFI_TIMEOUT;
2724 }
2725
2726 return EFI_SUCCESS;
2727 }
2728
2729 EFI_STATUS
2730 StatusDRQReady (
2731 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
2732 UINT64 TimeoutInMicroSeconds
2733 )
2734 /*++
2735
2736 Routine Description:
2737
2738 Check whether DRQ is ready in the Status Register. (BSY must also be cleared)
2739 If TimeoutInMicroSeconds is zero, this routine should wait infinitely for
2740 DRQ ready. Otherwise, it will return EFI_TIMEOUT when specified time is
2741 elapsed.
2742
2743 Arguments:
2744
2745 AtapiScsiPrivate - The pointer of ATAPI_SCSI_PASS_THRU_DEV
2746 TimeoutInMicroSeconds - The time to wait for
2747
2748 Returns:
2749
2750 EFI_STATUS
2751
2752 --*/
2753 {
2754 UINT64 Delay;
2755 UINT8 StatusRegister;
2756 UINT8 ErrRegister;
2757
2758 if (TimeoutInMicroSeconds == 0) {
2759 Delay = 2;
2760 } else {
2761 Delay = DivU64x32 (TimeoutInMicroSeconds, (UINT32) 30) + 1;
2762 }
2763
2764 do {
2765 //
2766 // read Status Register will clear interrupt
2767 //
2768 StatusRegister = ReadPortB (
2769 AtapiScsiPrivate->PciIo,
2770 AtapiScsiPrivate->IoPort->Reg.Status
2771 );
2772
2773 //
2774 // BSY==0,DRQ==1
2775 //
2776 if ((StatusRegister & (BSY | DRQ)) == DRQ) {
2777 break;
2778 }
2779
2780 if ((StatusRegister & (BSY | ERR)) == ERR) {
2781
2782 ErrRegister = ReadPortB (
2783 AtapiScsiPrivate->PciIo,
2784 AtapiScsiPrivate->IoPort->Reg1.Error
2785 );
2786 if ((ErrRegister & ABRT_ERR) == ABRT_ERR) {
2787 return EFI_ABORTED;
2788 }
2789 }
2790
2791 //
2792 // Stall for 30 us
2793 //
2794 gBS->Stall (30);
2795
2796 //
2797 // Loop infinitely if not meeting expected condition
2798 //
2799 if (TimeoutInMicroSeconds == 0) {
2800 Delay = 2;
2801 }
2802
2803 Delay--;
2804 } while (Delay);
2805
2806 if (Delay == 0) {
2807 return EFI_TIMEOUT;
2808 }
2809
2810 return EFI_SUCCESS;
2811 }
2812
2813 EFI_STATUS
2814 AltStatusDRQReady (
2815 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
2816 UINT64 TimeoutInMicroSeconds
2817 )
2818 /*++
2819
2820 Routine Description:
2821
2822 Check whether DRQ is ready in the Alternate Status Register.
2823 (BSY must also be cleared)
2824 If TimeoutInMicroSeconds is zero, this routine should wait infinitely for
2825 DRQ ready. Otherwise, it will return EFI_TIMEOUT when specified time is
2826 elapsed.
2827
2828 Arguments:
2829
2830 AtapiScsiPrivate - The pointer of ATAPI_SCSI_PASS_THRU_DEV
2831 TimeoutInMicroSeconds - The time to wait for
2832
2833 Returns:
2834
2835 EFI_STATUS
2836
2837 --*/
2838 {
2839 UINT64 Delay;
2840 UINT8 AltStatusRegister;
2841 UINT8 ErrRegister;
2842
2843 if (TimeoutInMicroSeconds == 0) {
2844 Delay = 2;
2845 } else {
2846 Delay = DivU64x32 (TimeoutInMicroSeconds, (UINT32) 30) + 1;
2847 }
2848
2849 do {
2850 //
2851 // read Status Register will clear interrupt
2852 //
2853 AltStatusRegister = ReadPortB (
2854 AtapiScsiPrivate->PciIo,
2855 AtapiScsiPrivate->IoPort->Alt.AltStatus
2856 );
2857 //
2858 // BSY==0,DRQ==1
2859 //
2860 if ((AltStatusRegister & (BSY | DRQ)) == DRQ) {
2861 break;
2862 }
2863
2864 if ((AltStatusRegister & (BSY | ERR)) == ERR) {
2865
2866 ErrRegister = ReadPortB (
2867 AtapiScsiPrivate->PciIo,
2868 AtapiScsiPrivate->IoPort->Reg1.Error
2869 );
2870 if ((ErrRegister & ABRT_ERR) == ABRT_ERR) {
2871 return EFI_ABORTED;
2872 }
2873 }
2874
2875 //
2876 // Stall for 30 us
2877 //
2878 gBS->Stall (30);
2879
2880 //
2881 // Loop infinitely if not meeting expected condition
2882 //
2883 if (TimeoutInMicroSeconds == 0) {
2884 Delay = 2;
2885 }
2886
2887 Delay--;
2888 } while (Delay);
2889
2890 if (Delay == 0) {
2891 return EFI_TIMEOUT;
2892 }
2893
2894 return EFI_SUCCESS;
2895 }
2896
2897 EFI_STATUS
2898 StatusWaitForBSYClear (
2899 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
2900 UINT64 TimeoutInMicroSeconds
2901 )
2902 /*++
2903
2904 Routine Description:
2905
2906 Check whether BSY is clear in the Status Register.
2907 If TimeoutInMicroSeconds is zero, this routine should wait infinitely for
2908 BSY clear. Otherwise, it will return EFI_TIMEOUT when specified time is
2909 elapsed.
2910
2911 Arguments:
2912
2913 AtapiScsiPrivate - The pointer of ATAPI_SCSI_PASS_THRU_DEV
2914 TimeoutInMicroSeconds - The time to wait for
2915
2916 Returns:
2917
2918 EFI_STATUS
2919
2920 --*/
2921 {
2922 UINT64 Delay;
2923 UINT8 StatusRegister;
2924
2925 if (TimeoutInMicroSeconds == 0) {
2926 Delay = 2;
2927 } else {
2928 Delay = DivU64x32 (TimeoutInMicroSeconds, (UINT32) 30) + 1;
2929 }
2930
2931 do {
2932
2933 StatusRegister = ReadPortB (
2934 AtapiScsiPrivate->PciIo,
2935 AtapiScsiPrivate->IoPort->Reg.Status
2936 );
2937 if ((StatusRegister & BSY) == 0x00) {
2938 break;
2939 }
2940
2941 //
2942 // Stall for 30 us
2943 //
2944 gBS->Stall (30);
2945
2946 //
2947 // Loop infinitely if not meeting expected condition
2948 //
2949 if (TimeoutInMicroSeconds == 0) {
2950 Delay = 2;
2951 }
2952
2953 Delay--;
2954 } while (Delay);
2955
2956 if (Delay == 0) {
2957 return EFI_TIMEOUT;
2958 }
2959
2960 return EFI_SUCCESS;
2961 }
2962
2963 EFI_STATUS
2964 AltStatusWaitForBSYClear (
2965 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
2966 UINT64 TimeoutInMicroSeconds
2967 )
2968 /*++
2969
2970 Routine Description:
2971
2972 Check whether BSY is clear in the Alternate Status Register.
2973 If TimeoutInMicroSeconds is zero, this routine should wait infinitely for
2974 BSY clear. Otherwise, it will return EFI_TIMEOUT when specified time is
2975 elapsed.
2976
2977 Arguments:
2978
2979 AtapiScsiPrivate - The pointer of ATAPI_SCSI_PASS_THRU_DEV
2980 TimeoutInMicroSeconds - The time to wait for
2981
2982 Returns:
2983
2984 EFI_STATUS
2985
2986 --*/
2987 {
2988 UINT64 Delay;
2989 UINT8 AltStatusRegister;
2990
2991 if (TimeoutInMicroSeconds == 0) {
2992 Delay = 2;
2993 } else {
2994 Delay = DivU64x32 (TimeoutInMicroSeconds, (UINT32) 30) + 1;
2995 }
2996
2997 do {
2998
2999 AltStatusRegister = ReadPortB (
3000 AtapiScsiPrivate->PciIo,
3001 AtapiScsiPrivate->IoPort->Alt.AltStatus
3002 );
3003 if ((AltStatusRegister & BSY) == 0x00) {
3004 break;
3005 }
3006
3007 //
3008 // Stall for 30 us
3009 //
3010 gBS->Stall (30);
3011 //
3012 // Loop infinitely if not meeting expected condition
3013 //
3014 if (TimeoutInMicroSeconds == 0) {
3015 Delay = 2;
3016 }
3017
3018 Delay--;
3019 } while (Delay);
3020
3021 if (Delay == 0) {
3022 return EFI_TIMEOUT;
3023 }
3024
3025 return EFI_SUCCESS;
3026 }
3027
3028 EFI_STATUS
3029 StatusDRDYReady (
3030 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
3031 UINT64 TimeoutInMicroSeconds
3032 )
3033 /*++
3034
3035 Routine Description:
3036
3037 Check whether DRDY is ready in the Status Register.
3038 (BSY must also be cleared)
3039 If TimeoutInMicroSeconds is zero, this routine should wait infinitely for
3040 DRDY ready. Otherwise, it will return EFI_TIMEOUT when specified time is
3041 elapsed.
3042
3043 Arguments:
3044
3045 AtapiScsiPrivate - The pointer of ATAPI_SCSI_PASS_THRU_DEV
3046 TimeoutInMicroSeconds - The time to wait for
3047
3048 Returns:
3049
3050 EFI_STATUS
3051
3052 --*/
3053 {
3054 UINT64 Delay;
3055 UINT8 StatusRegister;
3056 UINT8 ErrRegister;
3057
3058 if (TimeoutInMicroSeconds == 0) {
3059 Delay = 2;
3060 } else {
3061 Delay = DivU64x32 (TimeoutInMicroSeconds, (UINT32) 30) + 1;
3062 }
3063
3064 do {
3065 StatusRegister = ReadPortB (
3066 AtapiScsiPrivate->PciIo,
3067 AtapiScsiPrivate->IoPort->Reg.Status
3068 );
3069 //
3070 // BSY == 0 , DRDY == 1
3071 //
3072 if ((StatusRegister & (DRDY | BSY)) == DRDY) {
3073 break;
3074 }
3075
3076 if ((StatusRegister & (BSY | ERR)) == ERR) {
3077
3078 ErrRegister = ReadPortB (
3079 AtapiScsiPrivate->PciIo,
3080 AtapiScsiPrivate->IoPort->Reg1.Error
3081 );
3082 if ((ErrRegister & ABRT_ERR) == ABRT_ERR) {
3083 return EFI_ABORTED;
3084 }
3085 }
3086
3087 //
3088 // Stall for 30 us
3089 //
3090 gBS->Stall (30);
3091 //
3092 // Loop infinitely if not meeting expected condition
3093 //
3094 if (TimeoutInMicroSeconds == 0) {
3095 Delay = 2;
3096 }
3097
3098 Delay--;
3099 } while (Delay);
3100
3101 if (Delay == 0) {
3102 return EFI_TIMEOUT;
3103 }
3104
3105 return EFI_SUCCESS;
3106 }
3107
3108 EFI_STATUS
3109 AltStatusDRDYReady (
3110 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate,
3111 UINT64 TimeoutInMicroSeconds
3112 )
3113 /*++
3114
3115 Routine Description:
3116
3117 Check whether DRDY is ready in the Alternate Status Register.
3118 (BSY must also be cleared)
3119 If TimeoutInMicroSeconds is zero, this routine should wait infinitely for
3120 DRDY ready. Otherwise, it will return EFI_TIMEOUT when specified time is
3121 elapsed.
3122
3123 Arguments:
3124
3125 AtapiScsiPrivate - The pointer of ATAPI_SCSI_PASS_THRU_DEV
3126 TimeoutInMicroSeconds - The time to wait for
3127
3128 Returns:
3129
3130 EFI_STATUS
3131
3132 --*/
3133 {
3134 UINT64 Delay;
3135 UINT8 AltStatusRegister;
3136 UINT8 ErrRegister;
3137
3138 if (TimeoutInMicroSeconds == 0) {
3139 Delay = 2;
3140 } else {
3141 Delay = DivU64x32 (TimeoutInMicroSeconds, (UINT32) 30) + 1;
3142 }
3143
3144 do {
3145 AltStatusRegister = ReadPortB (
3146 AtapiScsiPrivate->PciIo,
3147 AtapiScsiPrivate->IoPort->Alt.AltStatus
3148 );
3149 //
3150 // BSY == 0 , DRDY == 1
3151 //
3152 if ((AltStatusRegister & (DRDY | BSY)) == DRDY) {
3153 break;
3154 }
3155
3156 if ((AltStatusRegister & (BSY | ERR)) == ERR) {
3157
3158 ErrRegister = ReadPortB (
3159 AtapiScsiPrivate->PciIo,
3160 AtapiScsiPrivate->IoPort->Reg1.Error
3161 );
3162 if ((ErrRegister & ABRT_ERR) == ABRT_ERR) {
3163 return EFI_ABORTED;
3164 }
3165 }
3166
3167 //
3168 // Stall for 30 us
3169 //
3170 gBS->Stall (30);
3171 //
3172 // Loop infinitely if not meeting expected condition
3173 //
3174 if (TimeoutInMicroSeconds == 0) {
3175 Delay = 2;
3176 }
3177
3178 Delay--;
3179 } while (Delay);
3180
3181 if (Delay == 0) {
3182 return EFI_TIMEOUT;
3183 }
3184
3185 return EFI_SUCCESS;
3186 }
3187
3188 EFI_STATUS
3189 AtapiPassThruCheckErrorStatus (
3190 ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate
3191 )
3192 /*++
3193
3194 Routine Description:
3195
3196 Check Error Register for Error Information.
3197
3198 Arguments:
3199
3200 AtapiScsiPrivate - The pointer of ATAPI_SCSI_PASS_THRU_DEV
3201
3202 Returns:
3203
3204 EFI_STATUS
3205
3206 --*/
3207 {
3208 UINT8 StatusRegister;
3209 UINT8 ErrorRegister;
3210
3211 StatusRegister = ReadPortB (
3212 AtapiScsiPrivate->PciIo,
3213 AtapiScsiPrivate->IoPort->Reg.Status
3214 );
3215
3216 DEBUG_CODE_BEGIN ();
3217
3218 if (StatusRegister & DWF) {
3219 DEBUG (
3220 (EFI_D_BLKIO,
3221 "AtapiPassThruCheckErrorStatus()-- %02x : Error : Write Fault\n",
3222 StatusRegister)
3223 );
3224 }
3225
3226 if (StatusRegister & CORR) {
3227 DEBUG (
3228 (EFI_D_BLKIO,
3229 "AtapiPassThruCheckErrorStatus()-- %02x : Error : Corrected Data\n",
3230 StatusRegister)
3231 );
3232 }
3233
3234 if (StatusRegister & ERR) {
3235 ErrorRegister = ReadPortB (AtapiScsiPrivate->PciIo, AtapiScsiPrivate->IoPort->Reg1.Error);
3236
3237
3238 if (ErrorRegister & BBK_ERR) {
3239 DEBUG (
3240 (EFI_D_BLKIO,
3241 "AtapiPassThruCheckErrorStatus()-- %02x : Error : Bad Block Detected\n",
3242 ErrorRegister)
3243 );
3244 }
3245
3246 if (ErrorRegister & UNC_ERR) {
3247 DEBUG (
3248 (EFI_D_BLKIO,
3249 "AtapiPassThruCheckErrorStatus()-- %02x : Error : Uncorrectable Data\n",
3250 ErrorRegister)
3251 );
3252 }
3253
3254 if (ErrorRegister & MC_ERR) {
3255 DEBUG (
3256 (EFI_D_BLKIO,
3257 "AtapiPassThruCheckErrorStatus()-- %02x : Error : Media Change\n",
3258 ErrorRegister)
3259 );
3260 }
3261
3262 if (ErrorRegister & ABRT_ERR) {
3263 DEBUG (
3264 (EFI_D_BLKIO,
3265 "AtapiPassThruCheckErrorStatus()-- %02x : Error : Abort\n",
3266 ErrorRegister)
3267 );
3268 }
3269
3270 if (ErrorRegister & TK0NF_ERR) {
3271 DEBUG (
3272 (EFI_D_BLKIO,
3273 "AtapiPassThruCheckErrorStatus()-- %02x : Error : Track 0 Not Found\n",
3274 ErrorRegister)
3275 );
3276 }
3277
3278 if (ErrorRegister & AMNF_ERR) {
3279 DEBUG (
3280 (EFI_D_BLKIO,
3281 "AtapiPassThruCheckErrorStatus()-- %02x : Error : Address Mark Not Found\n",
3282 ErrorRegister)
3283 );
3284 }
3285 }
3286
3287 DEBUG_CODE_END ();
3288
3289 if ((StatusRegister & (ERR | DWF | CORR)) == 0) {
3290 return EFI_SUCCESS;
3291 }
3292
3293
3294 return EFI_DEVICE_ERROR;
3295 }
3296
3297
3298 /**
3299 Installs Scsi Pass Thru and/or Ext Scsi Pass Thru
3300 protocols based on feature flags.
3301
3302 @param Controller The controller handle to
3303 install these protocols on.
3304 @param AtapiScsiPrivate A pointer to the protocol private
3305 data structure.
3306
3307 @retval EFI_SUCCESS The installation succeeds.
3308 @retval other The installation fails.
3309
3310 **/
3311 EFI_STATUS
3312 InstallScsiPassThruProtocols (
3313 IN EFI_HANDLE *ControllerHandle,
3314 IN ATAPI_SCSI_PASS_THRU_DEV *AtapiScsiPrivate
3315 )
3316 {
3317 EFI_STATUS Status;
3318 EFI_SCSI_PASS_THRU_PROTOCOL *ScsiPassThru;
3319 EFI_EXT_SCSI_PASS_THRU_PROTOCOL *ExtScsiPassThru;
3320
3321 ScsiPassThru = &AtapiScsiPrivate->ScsiPassThru;
3322 ExtScsiPassThru = &AtapiScsiPrivate->ExtScsiPassThru;
3323
3324 if (FeaturePcdGet (PcdSupportScsiPassThru)) {
3325 ScsiPassThru = CopyMem (ScsiPassThru, &gScsiPassThruProtocolTemplate, sizeof (*ScsiPassThru));
3326 if (FeaturePcdGet (PcdSupportExtScsiPassThru)) {
3327 ExtScsiPassThru = CopyMem (ExtScsiPassThru, &gExtScsiPassThruProtocolTemplate, sizeof (*ExtScsiPassThru));
3328 Status = gBS->InstallMultipleProtocolInterfaces (
3329 ControllerHandle,
3330 &gEfiScsiPassThruProtocolGuid,
3331 ScsiPassThru,
3332 &gEfiExtScsiPassThruProtocolGuid,
3333 ExtScsiPassThru,
3334 NULL
3335 );
3336 } else {
3337 Status = gBS->InstallMultipleProtocolInterfaces (
3338 ControllerHandle,
3339 &gEfiScsiPassThruProtocolGuid,
3340 ScsiPassThru,
3341 NULL
3342 );
3343 }
3344 } else {
3345 if (FeaturePcdGet (PcdSupportExtScsiPassThru)) {
3346 ExtScsiPassThru = CopyMem (ExtScsiPassThru, &gExtScsiPassThruProtocolTemplate, sizeof (*ExtScsiPassThru));
3347 Status = gBS->InstallMultipleProtocolInterfaces (
3348 ControllerHandle,
3349 &gEfiExtScsiPassThruProtocolGuid,
3350 ExtScsiPassThru,
3351 NULL
3352 );
3353 } else {
3354 //
3355 // This driver must support either ScsiPassThru or
3356 // ExtScsiPassThru protocols
3357 //
3358 ASSERT (FALSE);
3359 Status = EFI_UNSUPPORTED;
3360 }
3361 }
3362
3363 return Status;
3364 }
3365
3366 /**
3367 The user Entry Point for module AtapiPassThru. The user code starts with this function.
3368
3369 @param[in] ImageHandle The firmware allocated handle for the EFI image.
3370 @param[in] SystemTable A pointer to the EFI System Table.
3371
3372 @retval EFI_SUCCESS The entry point is executed successfully.
3373 @retval other Some error occurs when executing this entry point.
3374
3375 **/
3376 EFI_STATUS
3377 EFIAPI
3378 InitializeAtapiPassThru(
3379 IN EFI_HANDLE ImageHandle,
3380 IN EFI_SYSTEM_TABLE *SystemTable
3381 )
3382 {
3383 EFI_STATUS Status;
3384
3385 //
3386 // Install driver model protocol(s).
3387 //
3388 Status = EfiLibInstallDriverBindingComponentName2 (
3389 ImageHandle,
3390 SystemTable,
3391 &gAtapiScsiPassThruDriverBinding,
3392 ImageHandle,
3393