]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Bus/Pci/EhciDxe/Ehci.c
projects / mirror_edk2.git / blob
? search:


5173a9d599c5abf74d326c3dcbc9b1cbda7f6da1
[mirror_edk2.git] / MdeModulePkg / Bus / Pci / EhciDxe / Ehci.c
1 /** @file
2 The Ehci controller driver.
3
4 EhciDxe driver is responsible for managing the behavior of EHCI controller.
5 It implements the interfaces of monitoring the status of all ports and transferring
6 Control, Bulk, Interrupt and Isochronous requests to Usb2.0 device.
7
8 Note that EhciDxe driver is enhanced to guarantee that the EHCI controller get attached
9 to the EHCI controller before a UHCI or OHCI driver attaches to the companion UHCI or
10 OHCI controller. This way avoids the control transfer on a shared port between EHCI
11 and companion host controller when UHCI or OHCI gets attached earlier than EHCI and a
12 USB 2.0 device inserts.
13
14 Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>
15 This program and the accompanying materials
16 are licensed and made available under the terms and conditions of the BSD License
17 which accompanies this distribution. The full text of the license may be found at
18 http://opensource.org/licenses/bsd-license.php
19
20 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
21 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
22
23 **/
24
25
26 #include "Ehci.h"
27
28 //
29 // Two arrays used to translate the EHCI port state (change)
30 // to the UEFI protocol's port state (change).
31 //
32 USB_PORT_STATE_MAP mUsbPortStateMap[] = {
33 {PORTSC_CONN, USB_PORT_STAT_CONNECTION},
34 {PORTSC_ENABLED, USB_PORT_STAT_ENABLE},
35 {PORTSC_SUSPEND, USB_PORT_STAT_SUSPEND},
36 {PORTSC_OVERCUR, USB_PORT_STAT_OVERCURRENT},
37 {PORTSC_RESET, USB_PORT_STAT_RESET},
38 {PORTSC_POWER, USB_PORT_STAT_POWER},
39 {PORTSC_OWNER, USB_PORT_STAT_OWNER}
40 };
41
42 USB_PORT_STATE_MAP mUsbPortChangeMap[] = {
43 {PORTSC_CONN_CHANGE, USB_PORT_STAT_C_CONNECTION},
44 {PORTSC_ENABLE_CHANGE, USB_PORT_STAT_C_ENABLE},
45 {PORTSC_OVERCUR_CHANGE, USB_PORT_STAT_C_OVERCURRENT}
46 };
47
48 EFI_DRIVER_BINDING_PROTOCOL
49 gEhciDriverBinding = {
50 EhcDriverBindingSupported,
51 EhcDriverBindingStart,
52 EhcDriverBindingStop,
53 0x30,
54 NULL,
55 NULL
56 };
57
58 /**
59 Retrieves the capability of root hub ports.
60
61 @param This This EFI_USB_HC_PROTOCOL instance.
62 @param MaxSpeed Max speed supported by the controller.
63 @param PortNumber Number of the root hub ports.
64 @param Is64BitCapable Whether the controller supports 64-bit memory
65 addressing.
66
67 @retval EFI_SUCCESS Host controller capability were retrieved successfully.
68 @retval EFI_INVALID_PARAMETER Either of the three capability pointer is NULL.
69
70 **/
71 EFI_STATUS
72 EFIAPI
73 EhcGetCapability (
74 IN EFI_USB2_HC_PROTOCOL *This,
75 OUT UINT8 *MaxSpeed,
76 OUT UINT8 *PortNumber,
77 OUT UINT8 *Is64BitCapable
78 )
79 {
80 USB2_HC_DEV *Ehc;
81 EFI_TPL OldTpl;
82
83 if ((MaxSpeed == NULL) || (PortNumber == NULL) || (Is64BitCapable == NULL)) {
84 return EFI_INVALID_PARAMETER;
85 }
86
87 OldTpl = gBS->RaiseTPL (EHC_TPL);
88 Ehc = EHC_FROM_THIS (This);
89
90 *MaxSpeed = EFI_USB_SPEED_HIGH;
91 *PortNumber = (UINT8) (Ehc->HcStructParams & HCSP_NPORTS);
92 *Is64BitCapable = (UINT8) Ehc->Support64BitDma;
93
94 DEBUG ((EFI_D_INFO, "EhcGetCapability: %d ports, 64 bit %d\n", *PortNumber, *Is64BitCapable));
95
96 gBS->RestoreTPL (OldTpl);
97 return EFI_SUCCESS;
98 }
99
100
101 /**
102 Provides software reset for the USB host controller.
103
104 @param This This EFI_USB2_HC_PROTOCOL instance.
105 @param Attributes A bit mask of the reset operation to perform.
106
107 @retval EFI_SUCCESS The reset operation succeeded.
108 @retval EFI_INVALID_PARAMETER Attributes is not valid.
109 @retval EFI_UNSUPPOURTED The type of reset specified by Attributes is
110 not currently supported by the host controller.
111 @retval EFI_DEVICE_ERROR Host controller isn't halted to reset.
112
113 **/
114 EFI_STATUS
115 EFIAPI
116 EhcReset (
117 IN EFI_USB2_HC_PROTOCOL *This,
118 IN UINT16 Attributes
119 )
120 {
121 USB2_HC_DEV *Ehc;
122 EFI_TPL OldTpl;
123 EFI_STATUS Status;
124 UINT32 DbgCtrlStatus;
125
126 Ehc = EHC_FROM_THIS (This);
127
128 if (Ehc->DevicePath != NULL) {
129 //
130 // Report Status Code to indicate reset happens
131 //
132 REPORT_STATUS_CODE_WITH_DEVICE_PATH (
133 EFI_PROGRESS_CODE,
134 (EFI_IO_BUS_USB | EFI_IOB_PC_RESET),
135 Ehc->DevicePath
136 );
137 }
138
139 OldTpl = gBS->RaiseTPL (EHC_TPL);
140
141 switch (Attributes) {
142 case EFI_USB_HC_RESET_GLOBAL:
143 //
144 // Flow through, same behavior as Host Controller Reset
145 //
146 case EFI_USB_HC_RESET_HOST_CONTROLLER:
147 //
148 // Host Controller must be Halt when Reset it
149 //
150 if (Ehc->DebugPortNum != 0) {
151 DbgCtrlStatus = EhcReadDbgRegister(Ehc, 0);
152 if ((DbgCtrlStatus & (USB_DEBUG_PORT_IN_USE | USB_DEBUG_PORT_OWNER)) == (USB_DEBUG_PORT_IN_USE | USB_DEBUG_PORT_OWNER)) {
153 Status = EFI_SUCCESS;
154 goto ON_EXIT;
155 }
156 }
157
158 if (!EhcIsHalt (Ehc)) {
159 Status = EhcHaltHC (Ehc, EHC_GENERIC_TIMEOUT);
160
161 if (EFI_ERROR (Status)) {
162 Status = EFI_DEVICE_ERROR;
163 goto ON_EXIT;
164 }
165 }
166
167 //
168 // Clean up the asynchronous transfers, currently only
169 // interrupt supports asynchronous operation.
170 //
171 EhciDelAllAsyncIntTransfers (Ehc);
172 EhcAckAllInterrupt (Ehc);
173 EhcFreeSched (Ehc);
174
175 Status = EhcResetHC (Ehc, EHC_RESET_TIMEOUT);
176
177 if (EFI_ERROR (Status)) {
178 goto ON_EXIT;
179 }
180
181 Status = EhcInitHC (Ehc);
182 break;
183
184 case EFI_USB_HC_RESET_GLOBAL_WITH_DEBUG:
185 case EFI_USB_HC_RESET_HOST_WITH_DEBUG:
186 Status = EFI_UNSUPPORTED;
187 break;
188
189 default:
190 Status = EFI_INVALID_PARAMETER;
191 }
192
193 ON_EXIT:
194 DEBUG ((EFI_D_INFO, "EhcReset: exit status %r\n", Status));
195 gBS->RestoreTPL (OldTpl);
196 return Status;
197 }
198
199
200 /**
201 Retrieve the current state of the USB host controller.
202
203 @param This This EFI_USB2_HC_PROTOCOL instance.
204 @param State Variable to return the current host controller
205 state.
206
207 @retval EFI_SUCCESS Host controller state was returned in State.
208 @retval EFI_INVALID_PARAMETER State is NULL.
209 @retval EFI_DEVICE_ERROR An error was encountered while attempting to
210 retrieve the host controller's current state.
211
212 **/
213 EFI_STATUS
214 EFIAPI
215 EhcGetState (
216 IN EFI_USB2_HC_PROTOCOL *This,
217 OUT EFI_USB_HC_STATE *State
218 )
219 {
220 EFI_TPL OldTpl;
221 USB2_HC_DEV *Ehc;
222
223 if (State == NULL) {
224 return EFI_INVALID_PARAMETER;
225 }
226
227 OldTpl = gBS->RaiseTPL (EHC_TPL);
228 Ehc = EHC_FROM_THIS (This);
229
230 if (EHC_REG_BIT_IS_SET (Ehc, EHC_USBSTS_OFFSET, USBSTS_HALT)) {
231 *State = EfiUsbHcStateHalt;
232 } else {
233 *State = EfiUsbHcStateOperational;
234 }
235
236 gBS->RestoreTPL (OldTpl);
237
238 DEBUG ((EFI_D_INFO, "EhcGetState: current state %d\n", *State));
239 return EFI_SUCCESS;
240 }
241
242
243 /**
244 Sets the USB host controller to a specific state.
245
246 @param This This EFI_USB2_HC_PROTOCOL instance.
247 @param State The state of the host controller that will be set.
248
249 @retval EFI_SUCCESS The USB host controller was successfully placed
250 in the state specified by State.
251 @retval EFI_INVALID_PARAMETER State is invalid.
252 @retval EFI_DEVICE_ERROR Failed to set the state due to device error.
253
254 **/
255 EFI_STATUS
256 EFIAPI
257 EhcSetState (
258 IN EFI_USB2_HC_PROTOCOL *This,
259 IN EFI_USB_HC_STATE State
260 )
261 {
262 USB2_HC_DEV *Ehc;
263 EFI_TPL OldTpl;
264 EFI_STATUS Status;
265 EFI_USB_HC_STATE CurState;
266
267 Status = EhcGetState (This, &CurState);
268
269 if (EFI_ERROR (Status)) {
270 return EFI_DEVICE_ERROR;
271 }
272
273 if (CurState == State) {
274 return EFI_SUCCESS;
275 }
276
277 OldTpl = gBS->RaiseTPL (EHC_TPL);
278 Ehc = EHC_FROM_THIS (This);
279
280 switch (State) {
281 case EfiUsbHcStateHalt:
282 Status = EhcHaltHC (Ehc, EHC_GENERIC_TIMEOUT);
283 break;
284
285 case EfiUsbHcStateOperational:
286 if (EHC_REG_BIT_IS_SET (Ehc, EHC_USBSTS_OFFSET, USBSTS_SYS_ERROR)) {
287 Status = EFI_DEVICE_ERROR;
288 break;
289 }
290
291 //
292 // Software must not write a one to this field unless the host controller
293 // is in the Halted state. Doing so will yield undefined results.
294 // refers to Spec[EHCI1.0-2.3.1]
295 //
296 if (!EHC_REG_BIT_IS_SET (Ehc, EHC_USBSTS_OFFSET, USBSTS_HALT)) {
297 Status = EFI_DEVICE_ERROR;
298 break;
299 }
300
301 Status = EhcRunHC (Ehc, EHC_GENERIC_TIMEOUT);
302 break;
303
304 case EfiUsbHcStateSuspend:
305 Status = EFI_UNSUPPORTED;
306 break;
307
308 default:
309 Status = EFI_INVALID_PARAMETER;
310 }
311
312 DEBUG ((EFI_D_INFO, "EhcSetState: exit status %r\n", Status));
313 gBS->RestoreTPL (OldTpl);
314 return Status;
315 }
316
317
318 /**
319 Retrieves the current status of a USB root hub port.
320
321 @param This This EFI_USB2_HC_PROTOCOL instance.
322 @param PortNumber The root hub port to retrieve the state from.
323 This value is zero-based.
324 @param PortStatus Variable to receive the port state.
325
326 @retval EFI_SUCCESS The status of the USB root hub port specified.
327 by PortNumber was returned in PortStatus.
328 @retval EFI_INVALID_PARAMETER PortNumber is invalid.
329 @retval EFI_DEVICE_ERROR Can't read register.
330
331 **/
332 EFI_STATUS
333 EFIAPI
334 EhcGetRootHubPortStatus (
335 IN EFI_USB2_HC_PROTOCOL *This,
336 IN UINT8 PortNumber,
337 OUT EFI_USB_PORT_STATUS *PortStatus
338 )
339 {
340 USB2_HC_DEV *Ehc;
341 EFI_TPL OldTpl;
342 UINT32 Offset;
343 UINT32 State;
344 UINT32 TotalPort;
345 UINTN Index;
346 UINTN MapSize;
347 EFI_STATUS Status;
348 UINT32 DbgCtrlStatus;
349
350 if (PortStatus == NULL) {
351 return EFI_INVALID_PARAMETER;
352 }
353
354 OldTpl = gBS->RaiseTPL (EHC_TPL);
355
356 Ehc = EHC_FROM_THIS (This);
357 Status = EFI_SUCCESS;
358
359 TotalPort = (Ehc->HcStructParams & HCSP_NPORTS);
360
361 if (PortNumber >= TotalPort) {
362 Status = EFI_INVALID_PARAMETER;
363 goto ON_EXIT;
364 }
365
366 Offset = (UINT32) (EHC_PORT_STAT_OFFSET + (4 * PortNumber));
367 PortStatus->PortStatus = 0;
368 PortStatus->PortChangeStatus = 0;
369
370 if ((Ehc->DebugPortNum != 0) && (PortNumber == (Ehc->DebugPortNum - 1))) {
371 DbgCtrlStatus = EhcReadDbgRegister(Ehc, 0);
372 if ((DbgCtrlStatus & (USB_DEBUG_PORT_IN_USE | USB_DEBUG_PORT_OWNER)) == (USB_DEBUG_PORT_IN_USE | USB_DEBUG_PORT_OWNER)) {
373 goto ON_EXIT;
374 }
375 }
376
377 State = EhcReadOpReg (Ehc, Offset);
378
379 //
380 // Identify device speed. If in K state, it is low speed.
381 // If the port is enabled after reset, the device is of
382 // high speed. The USB bus driver should retrieve the actual
383 // port speed after reset.
384 //
385 if (EHC_BIT_IS_SET (State, PORTSC_LINESTATE_K)) {
386 PortStatus->PortStatus |= USB_PORT_STAT_LOW_SPEED;
387
388 } else if (EHC_BIT_IS_SET (State, PORTSC_ENABLED)) {
389 PortStatus->PortStatus |= USB_PORT_STAT_HIGH_SPEED;
390 }
391
392 //
393 // Convert the EHCI port/port change state to UEFI status
394 //
395 MapSize = sizeof (mUsbPortStateMap) / sizeof (USB_PORT_STATE_MAP);
396
397 for (Index = 0; Index < MapSize; Index++) {
398 if (EHC_BIT_IS_SET (State, mUsbPortStateMap[Index].HwState)) {
399 PortStatus->PortStatus = (UINT16) (PortStatus->PortStatus | mUsbPortStateMap[Index].UefiState);
400 }
401 }
402
403 MapSize = sizeof (mUsbPortChangeMap) / sizeof (USB_PORT_STATE_MAP);
404
405 for (Index = 0; Index < MapSize; Index++) {
406 if (EHC_BIT_IS_SET (State, mUsbPortChangeMap[Index].HwState)) {
407 PortStatus->PortChangeStatus = (UINT16) (PortStatus->PortChangeStatus | mUsbPortChangeMap[Index].UefiState);
408 }
409 }
410
411 ON_EXIT:
412 gBS->RestoreTPL (OldTpl);
413 return Status;
414 }
415
416
417 /**
418 Sets a feature for the specified root hub port.
419
420 @param This This EFI_USB2_HC_PROTOCOL instance.
421 @param PortNumber Root hub port to set.
422 @param PortFeature Feature to set.
423
424 @retval EFI_SUCCESS The feature specified by PortFeature was set.
425 @retval EFI_INVALID_PARAMETER PortNumber is invalid or PortFeature is invalid.
426 @retval EFI_DEVICE_ERROR Can't read register.
427
428 **/
429 EFI_STATUS
430 EFIAPI
431 EhcSetRootHubPortFeature (
432 IN EFI_USB2_HC_PROTOCOL *This,
433 IN UINT8 PortNumber,
434 IN EFI_USB_PORT_FEATURE PortFeature
435 )
436 {
437 USB2_HC_DEV *Ehc;
438 EFI_TPL OldTpl;
439 UINT32 Offset;
440 UINT32 State;
441 UINT32 TotalPort;
442 EFI_STATUS Status;
443
444 OldTpl = gBS->RaiseTPL (EHC_TPL);
445 Ehc = EHC_FROM_THIS (This);
446 Status = EFI_SUCCESS;
447
448 TotalPort = (Ehc->HcStructParams & HCSP_NPORTS);
449
450 if (PortNumber >= TotalPort) {
451 Status = EFI_INVALID_PARAMETER;
452 goto ON_EXIT;
453 }
454
455 Offset = (UINT32) (EHC_PORT_STAT_OFFSET + (4 * PortNumber));
456 State = EhcReadOpReg (Ehc, Offset);
457
458 //
459 // Mask off the port status change bits, these bits are
460 // write clean bit
461 //
462 State &= ~PORTSC_CHANGE_MASK;
463
464 switch (PortFeature) {
465 case EfiUsbPortEnable:
466 //
467 // Sofeware can't set this bit, Port can only be enable by
468 // EHCI as a part of the reset and enable
469 //
470 State |= PORTSC_ENABLED;
471 EhcWriteOpReg (Ehc, Offset, State);
472 break;
473
474 case EfiUsbPortSuspend:
475 State |= PORTSC_SUSPEND;
476 EhcWriteOpReg (Ehc, Offset, State);
477 break;
478
479 case EfiUsbPortReset:
480 //
481 // Make sure Host Controller not halt before reset it
482 //
483 if (EhcIsHalt (Ehc)) {
484 Status = EhcRunHC (Ehc, EHC_GENERIC_TIMEOUT);
485
486 if (EFI_ERROR (Status)) {
487 DEBUG ((EFI_D_INFO, "EhcSetRootHubPortFeature :failed to start HC - %r\n", Status));
488 break;
489 }
490 }
491
492 //
493 // Set one to PortReset bit must also set zero to PortEnable bit
494 //
495 State |= PORTSC_RESET;
496 State &= ~PORTSC_ENABLED;
497 EhcWriteOpReg (Ehc, Offset, State);
498 break;
499
500 case EfiUsbPortPower:
501 //
502 // Set port power bit when PPC is 1
503 //
504 if ((Ehc->HcCapParams & HCSP_PPC) == HCSP_PPC) {
505 State |= PORTSC_POWER;
506 EhcWriteOpReg (Ehc, Offset, State);
507 }
508 break;
509
510 case EfiUsbPortOwner:
511 State |= PORTSC_OWNER;
512 EhcWriteOpReg (Ehc, Offset, State);
513 break;
514
515 default:
516 Status = EFI_INVALID_PARAMETER;
517 }
518
519 ON_EXIT:
520 DEBUG ((EFI_D_INFO, "EhcSetRootHubPortFeature: exit status %r\n", Status));
521
522 gBS->RestoreTPL (OldTpl);
523 return Status;
524 }
525
526
527 /**
528 Clears a feature for the specified root hub port.
529
530 @param This A pointer to the EFI_USB2_HC_PROTOCOL instance.
531 @param PortNumber Specifies the root hub port whose feature is
532 requested to be cleared.
533 @param PortFeature Indicates the feature selector associated with the
534 feature clear request.
535
536 @retval EFI_SUCCESS The feature specified by PortFeature was cleared
537 for the USB root hub port specified by PortNumber.
538 @retval EFI_INVALID_PARAMETER PortNumber is invalid or PortFeature is invalid.
539 @retval EFI_DEVICE_ERROR Can't read register.
540
541 **/
542 EFI_STATUS
543 EFIAPI
544 EhcClearRootHubPortFeature (
545 IN EFI_USB2_HC_PROTOCOL *This,
546 IN UINT8 PortNumber,
547 IN EFI_USB_PORT_FEATURE PortFeature
548 )
549 {
550 USB2_HC_DEV *Ehc;
551 EFI_TPL OldTpl;
552 UINT32 Offset;
553 UINT32 State;
554 UINT32 TotalPort;
555 EFI_STATUS Status;
556
557 OldTpl = gBS->RaiseTPL (EHC_TPL);
558 Ehc = EHC_FROM_THIS (This);
559 Status = EFI_SUCCESS;
560
561 TotalPort = (Ehc->HcStructParams & HCSP_NPORTS);
562
563 if (PortNumber >= TotalPort) {
564 Status = EFI_INVALID_PARAMETER;
565 goto ON_EXIT;
566 }
567
568 Offset = EHC_PORT_STAT_OFFSET + (4 * PortNumber);
569 State = EhcReadOpReg (Ehc, Offset);
570 State &= ~PORTSC_CHANGE_MASK;
571
572 switch (PortFeature) {
573 case EfiUsbPortEnable:
574 //
575 // Clear PORT_ENABLE feature means disable port.
576 //
577 State &= ~PORTSC_ENABLED;
578 EhcWriteOpReg (Ehc, Offset, State);
579 break;
580
581 case EfiUsbPortSuspend:
582 //
583 // A write of zero to this bit is ignored by the host
584 // controller. The host controller will unconditionally
585 // set this bit to a zero when:
586 // 1. software sets the Forct Port Resume bit to a zero from a one.
587 // 2. software sets the Port Reset bit to a one frome a zero.
588 //
589 State &= ~PORSTSC_RESUME;
590 EhcWriteOpReg (Ehc, Offset, State);
591 break;
592
593 case EfiUsbPortReset:
594 //
595 // Clear PORT_RESET means clear the reset signal.
596 //
597 State &= ~PORTSC_RESET;
598 EhcWriteOpReg (Ehc, Offset, State);
599 break;
600
601 case EfiUsbPortOwner:
602 //
603 // Clear port owner means this port owned by EHC
604 //
605 State &= ~PORTSC_OWNER;
606 EhcWriteOpReg (Ehc, Offset, State);
607 break;
608
609 case EfiUsbPortConnectChange:
610 //
611 // Clear connect status change
612 //
613 State |= PORTSC_CONN_CHANGE;
614 EhcWriteOpReg (Ehc, Offset, State);
615 break;
616
617 case EfiUsbPortEnableChange:
618 //
619 // Clear enable status change
620 //
621 State |= PORTSC_ENABLE_CHANGE;
622 EhcWriteOpReg (Ehc, Offset, State);
623 break;
624
625 case EfiUsbPortOverCurrentChange:
626 //
627 // Clear PortOverCurrent change
628 //
629 State |= PORTSC_OVERCUR_CHANGE;
630 EhcWriteOpReg (Ehc, Offset, State);
631 break;
632
633 case EfiUsbPortPower:
634 //
635 // Clear port power bit when PPC is 1
636 //
637 if ((Ehc->HcCapParams & HCSP_PPC) == HCSP_PPC) {
638 State &= ~PORTSC_POWER;
639 EhcWriteOpReg (Ehc, Offset, State);
640 }
641 break;
642 case EfiUsbPortSuspendChange:
643 case EfiUsbPortResetChange:
644 //
645 // Not supported or not related operation
646 //
647 break;
648
649 default:
650 Status = EFI_INVALID_PARAMETER;
651 break;
652 }
653
654 ON_EXIT:
655 DEBUG ((EFI_D_INFO, "EhcClearRootHubPortFeature: exit status %r\n", Status));
656 gBS->RestoreTPL (OldTpl);
657 return Status;
658 }
659
660
661 /**
662 Submits control transfer to a target USB device.
663
664 @param This This EFI_USB2_HC_PROTOCOL instance.
665 @param DeviceAddress The target device address.
666 @param DeviceSpeed Target device speed.
667 @param MaximumPacketLength Maximum packet size the default control transfer
668 endpoint is capable of sending or receiving.
669 @param Request USB device request to send.
670 @param TransferDirection Specifies the data direction for the data stage
671 @param Data Data buffer to be transmitted or received from USB
672 device.
673 @param DataLength The size (in bytes) of the data buffer.
674 @param TimeOut Indicates the maximum timeout, in millisecond.
675 @param Translator Transaction translator to be used by this device.
676 @param TransferResult Return the result of this control transfer.
677
678 @retval EFI_SUCCESS Transfer was completed successfully.
679 @retval EFI_OUT_OF_RESOURCES The transfer failed due to lack of resources.
680 @retval EFI_INVALID_PARAMETER Some parameters are invalid.
681 @retval EFI_TIMEOUT Transfer failed due to timeout.
682 @retval EFI_DEVICE_ERROR Transfer failed due to host controller or device error.
683
684 **/
685 EFI_STATUS
686 EFIAPI
687 EhcControlTransfer (
688 IN EFI_USB2_HC_PROTOCOL *This,
689 IN UINT8 DeviceAddress,
690 IN UINT8 DeviceSpeed,
691 IN UINTN MaximumPacketLength,
692 IN EFI_USB_DEVICE_REQUEST *Request,
693 IN EFI_USB_DATA_DIRECTION TransferDirection,
694 IN OUT VOID *Data,
695 IN OUT UINTN *DataLength,
696 IN UINTN TimeOut,
697 IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator,
698 OUT UINT32 *TransferResult
699 )
700 {
701 USB2_HC_DEV *Ehc;
702 URB *Urb;
703 EFI_TPL OldTpl;
704 UINT8 Endpoint;
705 EFI_STATUS Status;
706
707 //
708 // Validate parameters
709 //
710 if ((Request == NULL) || (TransferResult == NULL)) {
711 return EFI_INVALID_PARAMETER;
712 }
713
714 if ((TransferDirection != EfiUsbDataIn) &&
715 (TransferDirection != EfiUsbDataOut) &&
716 (TransferDirection != EfiUsbNoData)) {
717 return EFI_INVALID_PARAMETER;
718 }
719
720 if ((TransferDirection == EfiUsbNoData) &&
721 ((Data != NULL) || (*DataLength != 0))) {
722 return EFI_INVALID_PARAMETER;
723 }
724
725 if ((TransferDirection != EfiUsbNoData) &&
726 ((Data == NULL) || (*DataLength == 0))) {
727 return EFI_INVALID_PARAMETER;
728 }
729
730 if ((MaximumPacketLength != 8) && (MaximumPacketLength != 16) &&
731 (MaximumPacketLength != 32) && (MaximumPacketLength != 64)) {
732 return EFI_INVALID_PARAMETER;
733 }
734
735 if ((DeviceSpeed == EFI_USB_SPEED_LOW) && (MaximumPacketLength != 8)) {
736 return EFI_INVALID_PARAMETER;
737 }
738
739 OldTpl = gBS->RaiseTPL (EHC_TPL);
740 Ehc = EHC_FROM_THIS (This);
741
742 Status = EFI_DEVICE_ERROR;
743 *TransferResult = EFI_USB_ERR_SYSTEM;
744
745 if (EhcIsHalt (Ehc) || EhcIsSysError (Ehc)) {
746 DEBUG ((EFI_D_ERROR, "EhcControlTransfer: HC halted at entrance\n"));
747
748 EhcAckAllInterrupt (Ehc);
749 goto ON_EXIT;
750 }
751
752 EhcAckAllInterrupt (Ehc);
753
754 //
755 // Create a new URB, insert it into the asynchronous
756 // schedule list, then poll the execution status.
757 //
758 //
759 // Encode the direction in address, although default control
760 // endpoint is bidirectional. EhcCreateUrb expects this
761 // combination of Ep addr and its direction.
762 //
763 Endpoint = (UINT8) (0 | ((TransferDirection == EfiUsbDataIn) ? 0x80 : 0));
764 Urb = EhcCreateUrb (
765 Ehc,
766 DeviceAddress,
767 Endpoint,
768 DeviceSpeed,
769 0,
770 MaximumPacketLength,
771 Translator,
772 EHC_CTRL_TRANSFER,
773 Request,
774 Data,
775 *DataLength,
776 NULL,
777 NULL,
778 1
779 );
780
781 if (Urb == NULL) {
782 DEBUG ((EFI_D_ERROR, "EhcControlTransfer: failed to create URB"));
783
784 Status = EFI_OUT_OF_RESOURCES;
785 goto ON_EXIT;
786 }
787
788 EhcLinkQhToAsync (Ehc, Urb->Qh);
789 Status = EhcExecTransfer (Ehc, Urb, TimeOut);
790 EhcUnlinkQhFromAsync (Ehc, Urb->Qh);
791
792 //
793 // Get the status from URB. The result is updated in EhcCheckUrbResult
794 // which is called by EhcExecTransfer
795 //
796 *TransferResult = Urb->Result;
797 *DataLength = Urb->Completed;
798
799 if (*TransferResult == EFI_USB_NOERROR) {
800 Status = EFI_SUCCESS;
801 }
802
803 EhcAckAllInterrupt (Ehc);
804 EhcFreeUrb (Ehc, Urb);
805
806 ON_EXIT:
807 Ehc->PciIo->Flush (Ehc->PciIo);
808 gBS->RestoreTPL (OldTpl);
809
810 if (EFI_ERROR (Status)) {
811 DEBUG ((EFI_D_ERROR, "EhcControlTransfer: error - %r, transfer - %x\n", Status, *TransferResult));
812 }
813
814 return Status;
815 }
816
817
818 /**
819 Submits bulk transfer to a bulk endpoint of a USB device.
820
821 @param This This EFI_USB2_HC_PROTOCOL instance.
822 @param DeviceAddress Target device address.
823 @param EndPointAddress Endpoint number and its direction in bit 7.
824 @param DeviceSpeed Device speed, Low speed device doesn't support bulk
825 transfer.
826 @param MaximumPacketLength Maximum packet size the endpoint is capable of
827 sending or receiving.
828 @param DataBuffersNumber Number of data buffers prepared for the transfer.
829 @param Data Array of pointers to the buffers of data to transmit
830 from or receive into.
831 @param DataLength The lenght of the data buffer.
832 @param DataToggle On input, the initial data toggle for the transfer;
833 On output, it is updated to to next data toggle to
834 use of the subsequent bulk transfer.
835 @param TimeOut Indicates the maximum time, in millisecond, which
836 the transfer is allowed to complete.
837 @param Translator A pointr to the transaction translator data.
838 @param TransferResult A pointer to the detailed result information of the
839 bulk transfer.
840
841 @retval EFI_SUCCESS The transfer was completed successfully.
842 @retval EFI_OUT_OF_RESOURCES The transfer failed due to lack of resource.
843 @retval EFI_INVALID_PARAMETER Some parameters are invalid.
844 @retval EFI_TIMEOUT The transfer failed due to timeout.
845 @retval EFI_DEVICE_ERROR The transfer failed due to host controller error.
846
847 **/
848 EFI_STATUS
849 EFIAPI
850 EhcBulkTransfer (
851 IN EFI_USB2_HC_PROTOCOL *This,
852 IN UINT8 DeviceAddress,
853 IN UINT8 EndPointAddress,
854 IN UINT8 DeviceSpeed,
855 IN UINTN MaximumPacketLength,
856 IN UINT8 DataBuffersNumber,
857 IN OUT VOID *Data[EFI_USB_MAX_BULK_BUFFER_NUM],
858 IN OUT UINTN *DataLength,
859 IN OUT UINT8 *DataToggle,
860 IN UINTN TimeOut,
861 IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator,
862 OUT UINT32 *TransferResult
863 )
864 {
865 USB2_HC_DEV *Ehc;
866 URB *Urb;
867 EFI_TPL OldTpl;
868 EFI_STATUS Status;
869
870 //
871 // Validate the parameters
872 //
873 if ((DataLength == NULL) || (*DataLength == 0) ||
874 (Data == NULL) || (Data[0] == NULL) || (TransferResult == NULL)) {
875 return EFI_INVALID_PARAMETER;
876 }
877
878 if ((*DataToggle != 0) && (*DataToggle != 1)) {
879 return EFI_INVALID_PARAMETER;
880 }
881
882 if ((DeviceSpeed == EFI_USB_SPEED_LOW) ||
883 ((DeviceSpeed == EFI_USB_SPEED_FULL) && (MaximumPacketLength > 64)) ||
884 ((EFI_USB_SPEED_HIGH == DeviceSpeed) && (MaximumPacketLength > 512))) {
885 return EFI_INVALID_PARAMETER;
886 }
887
888 OldTpl = gBS->RaiseTPL (EHC_TPL);
889 Ehc = EHC_FROM_THIS (This);
890
891 *TransferResult = EFI_USB_ERR_SYSTEM;
892 Status = EFI_DEVICE_ERROR;
893
894 if (EhcIsHalt (Ehc) || EhcIsSysError (Ehc)) {
895 DEBUG ((EFI_D_ERROR, "EhcBulkTransfer: HC is halted\n"));
896
897 EhcAckAllInterrupt (Ehc);
898 goto ON_EXIT;
899 }
900
901 EhcAckAllInterrupt (Ehc);
902
903 //
904 // Create a new URB, insert it into the asynchronous
905 // schedule list, then poll the execution status.
906 //
907 Urb = EhcCreateUrb (
908 Ehc,
909 DeviceAddress,
910 EndPointAddress,
911 DeviceSpeed,
912 *DataToggle,
913 MaximumPacketLength,
914 Translator,
915 EHC_BULK_TRANSFER,
916 NULL,
917 Data[0],
918 *DataLength,
919 NULL,
920 NULL,
921 1
922 );
923
924 if (Urb == NULL) {
925 DEBUG ((EFI_D_ERROR, "EhcBulkTransfer: failed to create URB\n"));
926
927 Status = EFI_OUT_OF_RESOURCES;
928 goto ON_EXIT;
929 }
930
931 EhcLinkQhToAsync (Ehc, Urb->Qh);
932 Status = EhcExecTransfer (Ehc, Urb, TimeOut);
933 EhcUnlinkQhFromAsync (Ehc, Urb->Qh);
934
935 *TransferResult = Urb->Result;
936 *DataLength = Urb->Completed;
937 *DataToggle = Urb->DataToggle;
938
939 if (*TransferResult == EFI_USB_NOERROR) {
940 Status = EFI_SUCCESS;
941 }
942
943 EhcAckAllInterrupt (Ehc);
944 EhcFreeUrb (Ehc, Urb);
945
946 ON_EXIT:
947 Ehc->PciIo->Flush (Ehc->PciIo);
948 gBS->RestoreTPL (OldTpl);
949
950 if (EFI_ERROR (Status)) {
951 DEBUG ((EFI_D_ERROR, "EhcBulkTransfer: error - %r, transfer - %x\n", Status, *TransferResult));
952 }
953
954 return Status;
955 }
956
957
958 /**
959 Submits an asynchronous interrupt transfer to an
960 interrupt endpoint of a USB device.
961
962 @param This This EFI_USB2_HC_PROTOCOL instance.
963 @param DeviceAddress Target device address.
964 @param EndPointAddress Endpoint number and its direction encoded in bit 7
965 @param DeviceSpeed Indicates device speed.
966 @param MaximumPacketLength Maximum packet size the target endpoint is capable
967 @param IsNewTransfer If TRUE, to submit an new asynchronous interrupt
968 transfer If FALSE, to remove the specified
969 asynchronous interrupt.
970 @param DataToggle On input, the initial data toggle to use; on output,
971 it is updated to indicate the next data toggle.
972 @param PollingInterval The he interval, in milliseconds, that the transfer
973 is polled.
974 @param DataLength The length of data to receive at the rate specified
975 by PollingInterval.
976 @param Translator Transaction translator to use.
977 @param CallBackFunction Function to call at the rate specified by
978 PollingInterval.
979 @param Context Context to CallBackFunction.
980
981 @retval EFI_SUCCESS The request has been successfully submitted or canceled.
982 @retval EFI_INVALID_PARAMETER Some parameters are invalid.
983 @retval EFI_OUT_OF_RESOURCES The request failed due to a lack of resources.
984 @retval EFI_DEVICE_ERROR The transfer failed due to host controller error.
985
986 **/
987 EFI_STATUS
988 EFIAPI
989 EhcAsyncInterruptTransfer (
990 IN EFI_USB2_HC_PROTOCOL * This,
991 IN UINT8 DeviceAddress,
992 IN UINT8 EndPointAddress,
993 IN UINT8 DeviceSpeed,
994 IN UINTN MaximumPacketLength,
995 IN BOOLEAN IsNewTransfer,
996 IN OUT UINT8 *DataToggle,
997 IN UINTN PollingInterval,
998 IN UINTN DataLength,
999 IN EFI_USB2_HC_TRANSACTION_TRANSLATOR * Translator,
1000 IN EFI_ASYNC_USB_TRANSFER_CALLBACK CallBackFunction,
1001 IN VOID *Context OPTIONAL
1002 )
1003 {
1004 USB2_HC_DEV *Ehc;
1005 URB *Urb;
1006 EFI_TPL OldTpl;
1007 EFI_STATUS Status;
1008 UINT8 *Data;
1009
1010 //
1011 // Validate parameters
1012 //
1013 if (!EHCI_IS_DATAIN (EndPointAddress)) {
1014 return EFI_INVALID_PARAMETER;
1015 }
1016
1017 if (IsNewTransfer) {
1018 if (DataLength == 0) {
1019 return EFI_INVALID_PARAMETER;
1020 }
1021
1022 if ((*DataToggle != 1) && (*DataToggle != 0)) {
1023 return EFI_INVALID_PARAMETER;
1024 }
1025
1026 if ((PollingInterval > 255) || (PollingInterval < 1)) {
1027 return EFI_INVALID_PARAMETER;
1028 }
1029 }
1030
1031 OldTpl = gBS->RaiseTPL (EHC_TPL);
1032 Ehc = EHC_FROM_THIS (This);
1033
1034 //
1035 // Delete Async interrupt transfer request. DataToggle will return
1036 // the next data toggle to use.
1037 //
1038 if (!IsNewTransfer) {
1039 Status = EhciDelAsyncIntTransfer (Ehc, DeviceAddress, EndPointAddress, DataToggle);
1040
1041 DEBUG ((EFI_D_INFO, "EhcAsyncInterruptTransfer: remove old transfer - %r\n", Status));
1042 goto ON_EXIT;
1043 }
1044
1045 Status = EFI_SUCCESS;
1046
1047 if (EhcIsHalt (Ehc) || EhcIsSysError (Ehc)) {
1048 DEBUG ((EFI_D_ERROR, "EhcAsyncInterruptTransfer: HC is halt\n"));
1049 EhcAckAllInterrupt (Ehc);
1050
1051 Status = EFI_DEVICE_ERROR;
1052 goto ON_EXIT;
1053 }
1054
1055 EhcAckAllInterrupt (Ehc);
1056
1057 Data = AllocatePool (DataLength);
1058
1059 if (Data == NULL) {
1060 DEBUG ((EFI_D_ERROR, "EhcAsyncInterruptTransfer: failed to allocate buffer\n"));
1061
1062 Status = EFI_OUT_OF_RESOURCES;
1063 goto ON_EXIT;
1064 }
1065
1066 Urb = EhcCreateUrb (
1067 Ehc,
1068 DeviceAddress,
1069 EndPointAddress,
1070 DeviceSpeed,
1071 *DataToggle,
1072 MaximumPacketLength,
1073 Translator,
1074 EHC_INT_TRANSFER_ASYNC,
1075 NULL,
1076 Data,
1077 DataLength,
1078 CallBackFunction,
1079 Context,
1080 PollingInterval
1081 );
1082
1083 if (Urb == NULL) {
1084 DEBUG ((EFI_D_ERROR, "EhcAsyncInterruptTransfer: failed to create URB\n"));
1085
1086 gBS->FreePool (Data);
1087 Status = EFI_OUT_OF_RESOURCES;
1088 goto ON_EXIT;
1089 }
1090
1091 //
1092 // New asynchronous transfer must inserted to the head.
1093 // Check the comments in EhcMoniteAsyncRequests
1094 //
1095 EhcLinkQhToPeriod (Ehc, Urb->Qh);
1096 InsertHeadList (&Ehc->AsyncIntTransfers, &Urb->UrbList);
1097
1098 ON_EXIT:
1099 Ehc->PciIo->Flush (Ehc->PciIo);
1100 gBS->RestoreTPL (OldTpl);
1101
1102 return Status;
1103 }
1104
1105
1106 /**
1107 Submits synchronous interrupt transfer to an interrupt endpoint
1108 of a USB device.
1109
1110 @param This This EFI_USB2_HC_PROTOCOL instance.
1111 @param DeviceAddress Target device address.
1112 @param EndPointAddress Endpoint number and its direction encoded in bit 7
1113 @param DeviceSpeed Indicates device speed.
1114 @param MaximumPacketLength Maximum packet size the target endpoint is capable
1115 of sending or receiving.
1116 @param Data Buffer of data that will be transmitted to USB
1117 device or received from USB device.
1118 @param DataLength On input, the size, in bytes, of the data buffer; On
1119 output, the number of bytes transferred.
1120 @param DataToggle On input, the initial data toggle to use; on output,
1121 it is updated to indicate the next data toggle.
1122 @param TimeOut Maximum time, in second, to complete.
1123 @param Translator Transaction translator to use.
1124 @param TransferResult Variable to receive the transfer result.
1125
1126 @return EFI_SUCCESS The transfer was completed successfully.
1127 @return EFI_OUT_OF_RESOURCES The transfer failed due to lack of resource.
1128 @return EFI_INVALID_PARAMETER Some parameters are invalid.
1129 @return EFI_TIMEOUT The transfer failed due to timeout.
1130 @return EFI_DEVICE_ERROR The failed due to host controller or device error
1131
1132 **/
1133 EFI_STATUS
1134 EFIAPI
1135 EhcSyncInterruptTransfer (
1136 IN EFI_USB2_HC_PROTOCOL *This,
1137 IN UINT8 DeviceAddress,
1138 IN UINT8 EndPointAddress,
1139 IN UINT8 DeviceSpeed,
1140 IN UINTN MaximumPacketLength,
1141 IN OUT VOID *Data,
1142 IN OUT UINTN *DataLength,
1143 IN OUT UINT8 *DataToggle,
1144 IN UINTN TimeOut,
1145 IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator,
1146 OUT UINT32 *TransferResult
1147 )
1148 {
1149 USB2_HC_DEV *Ehc;
1150 EFI_TPL OldTpl;
1151 URB *Urb;
1152 EFI_STATUS Status;
1153
1154 //
1155 // Validates parameters
1156 //
1157 if ((DataLength == NULL) || (*DataLength == 0) ||
1158 (Data == NULL) || (TransferResult == NULL)) {
1159 return EFI_INVALID_PARAMETER;
1160 }
1161
1162 if ((*DataToggle != 1) && (*DataToggle != 0)) {
1163 return EFI_INVALID_PARAMETER;
1164 }
1165
1166 if (((DeviceSpeed == EFI_USB_SPEED_LOW) && (MaximumPacketLength != 8)) ||
1167 ((DeviceSpeed == EFI_USB_SPEED_FULL) && (MaximumPacketLength > 64)) ||
1168 ((DeviceSpeed == EFI_USB_SPEED_HIGH) && (MaximumPacketLength > 3072))) {
1169 return EFI_INVALID_PARAMETER;
1170 }
1171
1172 OldTpl = gBS->RaiseTPL (EHC_TPL);
1173 Ehc = EHC_FROM_THIS (This);
1174
1175 *TransferResult = EFI_USB_ERR_SYSTEM;
1176 Status = EFI_DEVICE_ERROR;
1177
1178 if (EhcIsHalt (Ehc) || EhcIsSysError (Ehc)) {
1179 DEBUG ((EFI_D_ERROR, "EhcSyncInterruptTransfer: HC is halt\n"));
1180
1181 EhcAckAllInterrupt (Ehc);
1182 goto ON_EXIT;
1183 }
1184
1185 EhcAckAllInterrupt (Ehc);
1186
1187 Urb = EhcCreateUrb (
1188 Ehc,
1189 DeviceAddress,
1190 EndPointAddress,
1191 DeviceSpeed,
1192 *DataToggle,
1193 MaximumPacketLength,
1194 Translator,
1195 EHC_INT_TRANSFER_SYNC,
1196 NULL,
1197 Data,
1198 *DataLength,
1199 NULL,
1200 NULL,
1201 1
1202 );
1203
1204 if (Urb == NULL) {
1205 DEBUG ((EFI_D_ERROR, "EhcSyncInterruptTransfer: failed to create URB\n"));
1206
1207 Status = EFI_OUT_OF_RESOURCES;
1208 goto ON_EXIT;
1209 }
1210
1211 EhcLinkQhToPeriod (Ehc, Urb->Qh);
1212 Status = EhcExecTransfer (Ehc, Urb, TimeOut);
1213 EhcUnlinkQhFromPeriod (Ehc, Urb->Qh);
1214
1215 *TransferResult = Urb->Result;
1216 *DataLength = Urb->Completed;
1217 *DataToggle = Urb->DataToggle;
1218
1219 if (*TransferResult == EFI_USB_NOERROR) {
1220 Status = EFI_SUCCESS;
1221 }
1222
1223 ON_EXIT:
1224 Ehc->PciIo->Flush (Ehc->PciIo);
1225 gBS->RestoreTPL (OldTpl);
1226
1227 if (EFI_ERROR (Status)) {
1228 DEBUG ((EFI_D_ERROR, "EhcSyncInterruptTransfer: error - %r, transfer - %x\n", Status, *TransferResult));
1229 }
1230
1231 return Status;
1232 }
1233
1234
1235 /**
1236 Submits isochronous transfer to a target USB device.
1237
1238 @param This This EFI_USB2_HC_PROTOCOL instance.
1239 @param DeviceAddress Target device address.
1240 @param EndPointAddress End point address with its direction.
1241 @param DeviceSpeed Device speed, Low speed device doesn't support this
1242 type.
1243 @param MaximumPacketLength Maximum packet size that the endpoint is capable of
1244 sending or receiving.
1245 @param DataBuffersNumber Number of data buffers prepared for the transfer.
1246 @param Data Array of pointers to the buffers of data that will
1247 be transmitted to USB device or received from USB
1248 device.
1249 @param DataLength The size, in bytes, of the data buffer.
1250 @param Translator Transaction translator to use.
1251 @param TransferResult Variable to receive the transfer result.
1252
1253 @return EFI_UNSUPPORTED Isochronous transfer is unsupported.
1254
1255 **/
1256 EFI_STATUS
1257 EFIAPI
1258 EhcIsochronousTransfer (
1259 IN EFI_USB2_HC_PROTOCOL *This,
1260 IN UINT8 DeviceAddress,
1261 IN UINT8 EndPointAddress,
1262 IN UINT8 DeviceSpeed,
1263 IN UINTN MaximumPacketLength,
1264 IN UINT8 DataBuffersNumber,
1265 IN OUT VOID *Data[EFI_USB_MAX_ISO_BUFFER_NUM],
1266 IN UINTN DataLength,
1267 IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator,
1268 OUT UINT32 *TransferResult
1269 )
1270 {
1271 return EFI_UNSUPPORTED;
1272 }
1273
1274
1275 /**
1276 Submits Async isochronous transfer to a target USB device.
1277
1278 @param This This EFI_USB2_HC_PROTOCOL instance.
1279 @param DeviceAddress Target device address.
1280 @param EndPointAddress End point address with its direction.
1281 @param DeviceSpeed Device speed, Low speed device doesn't support this
1282 type.
1283 @param MaximumPacketLength Maximum packet size that the endpoint is capable of
1284 sending or receiving.
1285 @param DataBuffersNumber Number of data buffers prepared for the transfer.
1286 @param Data Array of pointers to the buffers of data that will
1287 be transmitted to USB device or received from USB
1288 device.
1289 @param DataLength The size, in bytes, of the data buffer.
1290 @param Translator Transaction translator to use.
1291 @param IsochronousCallBack Function to be called when the transfer complete.
1292 @param Context Context passed to the call back function as
1293 parameter.
1294
1295 @return EFI_UNSUPPORTED Isochronous transfer isn't supported.
1296
1297 **/
1298 EFI_STATUS
1299 EFIAPI
1300 EhcAsyncIsochronousTransfer (
1301 IN EFI_USB2_HC_PROTOCOL *This,
1302 IN UINT8 DeviceAddress,
1303 IN UINT8 EndPointAddress,
1304 IN UINT8 DeviceSpeed,
1305 IN UINTN MaximumPacketLength,
1306 IN UINT8 DataBuffersNumber,
1307 IN OUT VOID *Data[EFI_USB_MAX_ISO_BUFFER_NUM],
1308 IN UINTN DataLength,
1309 IN EFI_USB2_HC_TRANSACTION_TRANSLATOR *Translator,
1310 IN EFI_ASYNC_USB_TRANSFER_CALLBACK IsochronousCallBack,
1311 IN VOID *Context
1312 )
1313 {
1314 return EFI_UNSUPPORTED;
1315 }
1316
1317 /**
1318 Entry point for EFI drivers.
1319
1320 @param ImageHandle EFI_HANDLE.
1321 @param SystemTable EFI_SYSTEM_TABLE.
1322
1323 @return EFI_SUCCESS Success.
1324 EFI_DEVICE_ERROR Fail.
1325
1326 **/
1327 EFI_STATUS
1328 EFIAPI
1329 EhcDriverEntryPoint (
1330 IN EFI_HANDLE ImageHandle,
1331 IN EFI_SYSTEM_TABLE *SystemTable
1332 )
1333 {
1334 return EfiLibInstallDriverBindingComponentName2 (
1335 ImageHandle,
1336 SystemTable,
1337 &gEhciDriverBinding,
1338 ImageHandle,
1339 &gEhciComponentName,
1340 &gEhciComponentName2
1341 );
1342 }
1343
1344
1345 /**
1346 Test to see if this driver supports ControllerHandle. Any
1347 ControllerHandle that has Usb2HcProtocol installed will
1348 be supported.
1349
1350 @param This Protocol instance pointer.
1351 @param Controller Handle of device to test.
1352 @param RemainingDevicePath Not used.
1353
1354 @return EFI_SUCCESS This driver supports this device.
1355 @return EFI_UNSUPPORTED This driver does not support this device.
1356
1357 **/
1358 EFI_STATUS
1359 EFIAPI
1360 EhcDriverBindingSupported (
1361 IN EFI_DRIVER_BINDING_PROTOCOL *This,
1362 IN EFI_HANDLE Controller,
1363 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
1364 )
1365 {
1366 EFI_STATUS Status;
1367 EFI_PCI_IO_PROTOCOL *PciIo;
1368 USB_CLASSC UsbClassCReg;
1369
1370 //
1371 // Test whether there is PCI IO Protocol attached on the controller handle.
1372 //
1373 Status = gBS->OpenProtocol (
1374 Controller,
1375 &gEfiPciIoProtocolGuid,
1376 (VOID **) &PciIo,
1377 This->DriverBindingHandle,
1378 Controller,
1379 EFI_OPEN_PROTOCOL_BY_DRIVER
1380 );
1381
1382 if (EFI_ERROR (Status)) {
1383 return EFI_UNSUPPORTED;
1384 }
1385
1386 Status = PciIo->Pci.Read (
1387 PciIo,
1388 EfiPciIoWidthUint8,
1389 PCI_CLASSCODE_OFFSET,
1390 sizeof (USB_CLASSC) / sizeof (UINT8),
1391 &UsbClassCReg
1392 );
1393
1394 if (EFI_ERROR (Status)) {
1395 Status = EFI_UNSUPPORTED;
1396 goto ON_EXIT;
1397 }
1398
1399 //
1400 // Test whether the controller belongs to Ehci type
1401 //
1402 if ((UsbClassCReg.BaseCode != PCI_CLASS_SERIAL) || (UsbClassCReg.SubClassCode != PCI_CLASS_SERIAL_USB)
1403 || ((UsbClassCReg.ProgInterface != PCI_IF_EHCI) && (UsbClassCReg.ProgInterface != PCI_IF_UHCI) && (UsbClassCReg.ProgInterface != PCI_IF_OHCI))) {
1404
1405 Status = EFI_UNSUPPORTED;
1406 }
1407
1408 ON_EXIT:
1409 gBS->CloseProtocol (
1410 Controller,
1411 &gEfiPciIoProtocolGuid,
1412 This->DriverBindingHandle,
1413 Controller
1414 );
1415
1416 return Status;
1417 }
1418
1419 /**
1420 Get the usb debug port related information.
1421
1422 @param Ehc The EHCI device.
1423
1424 @retval RETURN_SUCCESS Get debug port number, bar and offset successfully.
1425 @retval Others The usb host controller does not supported usb debug port capability.
1426
1427 **/
1428 EFI_STATUS
1429 EhcGetUsbDebugPortInfo (
1430 IN USB2_HC_DEV *Ehc
1431 )
1432 {
1433 EFI_PCI_IO_PROTOCOL *PciIo;
1434 UINT16 PciStatus;
1435 UINT8 CapabilityPtr;
1436 UINT8 CapabilityId;
1437 UINT16 DebugPort;
1438 EFI_STATUS Status;
1439
1440 ASSERT (Ehc->PciIo != NULL);
1441 PciIo = Ehc->PciIo;
1442
1443 //
1444 // Detect if the EHCI host controller support Capaility Pointer.
1445 //
1446 Status = PciIo->Pci.Read (
1447 PciIo,
1448 EfiPciIoWidthUint8,
1449 PCI_PRIMARY_STATUS_OFFSET,
1450 sizeof (UINT16),
1451 &PciStatus
1452 );
1453
1454 if (EFI_ERROR (Status)) {
1455 return Status;
1456 }
1457
1458 if ((PciStatus & EFI_PCI_STATUS_CAPABILITY) == 0) {
1459 //
1460 // The Pci Device Doesn't Support Capability Pointer.
1461 //
1462 return EFI_UNSUPPORTED;
1463 }
1464
1465 //
1466 // Get Pointer To Capability List
1467 //
1468 Status = PciIo->Pci.Read (
1469 PciIo,
1470 EfiPciIoWidthUint8,
1471 PCI_CAPBILITY_POINTER_OFFSET,
1472 1,
1473 &CapabilityPtr
1474 );
1475
1476 if (EFI_ERROR (Status)) {
1477 return Status;
1478 }
1479
1480 //
1481 // Find Capability ID 0xA, Which Is For Debug Port
1482 //
1483 while (CapabilityPtr != 0) {
1484 Status = PciIo->Pci.Read (
1485 PciIo,
1486 EfiPciIoWidthUint8,
1487 CapabilityPtr,
1488 1,
1489 &CapabilityId
1490 );
1491
1492 if (EFI_ERROR (Status)) {
1493 return Status;
1494 }
1495
1496 if (CapabilityId == EHC_DEBUG_PORT_CAP_ID) {
1497 break;
1498 }
1499
1500 Status = PciIo->Pci.Read (
1501 PciIo,
1502 EfiPciIoWidthUint8,
1503 CapabilityPtr + 1,
1504 1,
1505 &CapabilityPtr
1506 );
1507
1508 if (EFI_ERROR (Status)) {
1509 return Status;
1510 }
1511 }
1512
1513 //
1514 // No Debug Port Capability Found
1515 //
1516 if (CapabilityPtr == 0) {
1517 return EFI_UNSUPPORTED;
1518 }
1519
1520 //
1521 // Get The Base Address Of Debug Port Register In Debug Port Capability Register
1522 //
1523 Status = PciIo->Pci.Read (
1524 Ehc->PciIo,
1525 EfiPciIoWidthUint8,
1526 CapabilityPtr + 2,
1527 sizeof (UINT16),
1528 &DebugPort
1529 );
1530
1531 if (EFI_ERROR (Status)) {
1532 return Status;
1533 }
1534
1535 Ehc->DebugPortOffset = DebugPort & 0x1FFF;
1536 Ehc->DebugPortBarNum = (UINT8)((DebugPort >> 13) - 1);
1537 Ehc->DebugPortNum = (UINT8)((Ehc->HcStructParams & 0x00F00000) >> 20);
1538
1539 return EFI_SUCCESS;
1540 }
1541
1542
1543 /**
1544 Create and initialize a USB2_HC_DEV.
1545
1546 @param PciIo The PciIo on this device.
1547 @param DevicePath The device path of host controller.
1548 @param OriginalPciAttributes Original PCI attributes.
1549
1550 @return The allocated and initialized USB2_HC_DEV structure if created,
1551 otherwise NULL.
1552
1553 **/
1554 USB2_HC_DEV *
1555 EhcCreateUsb2Hc (
1556 IN EFI_PCI_IO_PROTOCOL *PciIo,
1557 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
1558 IN UINT64 OriginalPciAttributes
1559 )
1560 {
1561 USB2_HC_DEV *Ehc;
1562 EFI_STATUS Status;
1563
1564 Ehc = AllocateZeroPool (sizeof (USB2_HC_DEV));
1565
1566 if (Ehc == NULL) {
1567 return NULL;
1568 }
1569
1570 //
1571 // Init EFI_USB2_HC_PROTOCOL interface and private data structure
1572 //
1573 Ehc->Signature = USB2_HC_DEV_SIGNATURE;
1574
1575 Ehc->Usb2Hc.GetCapability = EhcGetCapability;
1576 Ehc->Usb2Hc.Reset = EhcReset;
1577 Ehc->Usb2Hc.GetState = EhcGetState;
1578 Ehc->Usb2Hc.SetState = EhcSetState;
1579 Ehc->Usb2Hc.ControlTransfer = EhcControlTransfer;
1580 Ehc->Usb2Hc.BulkTransfer = EhcBulkTransfer;
1581 Ehc->Usb2Hc.AsyncInterruptTransfer = EhcAsyncInterruptTransfer;
1582 Ehc->Usb2Hc.SyncInterruptTransfer = EhcSyncInterruptTransfer;
1583 Ehc->Usb2Hc.IsochronousTransfer = EhcIsochronousTransfer;
1584 Ehc->Usb2Hc.AsyncIsochronousTransfer = EhcAsyncIsochronousTransfer;
1585 Ehc->Usb2Hc.GetRootHubPortStatus = EhcGetRootHubPortStatus;
1586 Ehc->Usb2Hc.SetRootHubPortFeature = EhcSetRootHubPortFeature;
1587 Ehc->Usb2Hc.ClearRootHubPortFeature = EhcClearRootHubPortFeature;
1588 Ehc->Usb2Hc.MajorRevision = 0x2;
1589 Ehc->Usb2Hc.MinorRevision = 0x0;
1590
1591 Ehc->PciIo = PciIo;
1592 Ehc->DevicePath = DevicePath;
1593 Ehc->OriginalPciAttributes = OriginalPciAttributes;
1594
1595 InitializeListHead (&Ehc->AsyncIntTransfers);
1596
1597 Ehc->HcStructParams = EhcReadCapRegister (Ehc, EHC_HCSPARAMS_OFFSET);
1598 Ehc->HcCapParams = EhcReadCapRegister (Ehc, EHC_HCCPARAMS_OFFSET);
1599 Ehc->CapLen = EhcReadCapRegister (Ehc, EHC_CAPLENGTH_OFFSET) & 0x0FF;
1600
1601 DEBUG ((EFI_D_INFO, "EhcCreateUsb2Hc: capability length %d\n", Ehc->CapLen));
1602
1603 //
1604 // EHCI Controllers with a CapLen of 0 are ignored.
1605 //
1606 if (Ehc->CapLen == 0) {
1607 gBS->FreePool (Ehc);
1608 return NULL;
1609 }
1610
1611 EhcGetUsbDebugPortInfo (Ehc);
1612
1613 //
1614 // Create AsyncRequest Polling Timer
1615 //
1616 Status = gBS->CreateEvent (
1617 EVT_TIMER | EVT_NOTIFY_SIGNAL,
1618 TPL_NOTIFY,
1619 EhcMonitorAsyncRequests,
1620 Ehc,
1621 &Ehc->PollTimer
1622 );
1623
1624 if (EFI_ERROR (Status)) {
1625 gBS->FreePool (Ehc);
1626 return NULL;
1627 }
1628
1629 return Ehc;
1630 }
1631
1632 /**
1633 One notified function to stop the Host Controller when gBS->ExitBootServices() called.
1634
1635 @param Event Pointer to this event
1636 @param Context Event handler private data
1637
1638 **/
1639 VOID
1640 EFIAPI
1641 EhcExitBootService (
1642 EFI_EVENT Event,
1643 VOID *Context
1644 )
1645
1646 {
1647 USB2_HC_DEV *Ehc;
1648
1649 Ehc = (USB2_HC_DEV *) Context;
1650
1651 //
1652 // Reset the Host Controller
1653 //
1654 EhcResetHC (Ehc, EHC_RESET_TIMEOUT);
1655 }
1656
1657
1658 /**
1659 Starting the Usb EHCI Driver.
1660
1661 @param This Protocol instance pointer.
1662 @param Controller Handle of device to test.
1663 @param RemainingDevicePath Not used.
1664
1665 @return EFI_SUCCESS supports this device.
1666 @return EFI_UNSUPPORTED do not support this device.
1667 @return EFI_DEVICE_ERROR cannot be started due to device Error.
1668 @return EFI_OUT_OF_RESOURCES cannot allocate resources.
1669
1670 **/
1671 EFI_STATUS
1672 EFIAPI
1673 EhcDriverBindingStart (
1674 IN EFI_DRIVER_BINDING_PROTOCOL *This,
1675 IN EFI_HANDLE Controller,
1676 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
1677 )
1678 {
1679 EFI_STATUS Status;
1680 USB2_HC_DEV *Ehc;
1681 EFI_PCI_IO_PROTOCOL *PciIo;
1682 EFI_PCI_IO_PROTOCOL *Instance;
1683 UINT64 Supports;
1684 UINT64 OriginalPciAttributes;
1685 BOOLEAN PciAttributesSaved;
1686 USB_CLASSC UsbClassCReg;
1687 EFI_HANDLE *HandleBuffer;
1688 UINTN NumberOfHandles;
1689 UINTN Index;
1690 UINTN CompanionSegmentNumber;
1691 UINTN CompanionBusNumber;
1692 UINTN CompanionDeviceNumber;
1693 UINTN CompanionFunctionNumber;
1694 UINTN EhciSegmentNumber;
1695 UINTN EhciBusNumber;
1696 UINTN EhciDeviceNumber;
1697 UINTN EhciFunctionNumber;
1698 UINT32 State;
1699 EFI_DEVICE_PATH_PROTOCOL *HcDevicePath;
1700
1701 //
1702 // Open the PciIo Protocol, then enable the USB host controller
1703 //
1704 Status = gBS->OpenProtocol (
1705 Controller,
1706 &gEfiPciIoProtocolGuid,
1707 (VOID **) &PciIo,
1708 This->DriverBindingHandle,
1709 Controller,
1710 EFI_OPEN_PROTOCOL_BY_DRIVER
1711 );
1712
1713 if (EFI_ERROR (Status)) {
1714 return Status;
1715 }
1716
1717 //
1718 // Open Device Path Protocol for on USB host controller
1719 //
1720 HcDevicePath = NULL;
1721 Status = gBS->OpenProtocol (
1722 Controller,
1723 &gEfiDevicePathProtocolGuid,
1724 (VOID **) &HcDevicePath,
1725 This->DriverBindingHandle,
1726 Controller,
1727 EFI_OPEN_PROTOCOL_GET_PROTOCOL
1728 );
1729
1730 PciAttributesSaved = FALSE;
1731 //
1732 // Save original PCI attributes
1733 //
1734 Status = PciIo->Attributes (
1735 PciIo,
1736 EfiPciIoAttributeOperationGet,
1737 0,
1738 &OriginalPciAttributes
1739 );
1740
1741 if (EFI_ERROR (Status)) {
1742 goto CLOSE_PCIIO;
1743 }
1744 PciAttributesSaved = TRUE;
1745
1746 Status = PciIo->Attributes (
1747 PciIo,
1748 EfiPciIoAttributeOperationSupported,
1749 0,
1750 &Supports
1751 );
1752 if (!EFI_ERROR (Status)) {
1753 Supports &= (UINT64)EFI_PCI_DEVICE_ENABLE;
1754 Status = PciIo->Attributes (
1755 PciIo,
1756 EfiPciIoAttributeOperationEnable,
1757 Supports,
1758 NULL
1759 );
1760 }
1761
1762 if (EFI_ERROR (Status)) {
1763 DEBUG ((EFI_D_ERROR, "EhcDriverBindingStart: failed to enable controller\n"));
1764 goto CLOSE_PCIIO;
1765 }
1766
1767 //
1768 // Get the Pci device class code.
1769 //
1770 Status = PciIo->Pci.Read (
1771 PciIo,
1772 EfiPciIoWidthUint8,
1773 PCI_CLASSCODE_OFFSET,
1774 sizeof (USB_CLASSC) / sizeof (UINT8),
1775 &UsbClassCReg
1776 );
1777
1778 if (EFI_ERROR (Status)) {
1779 Status = EFI_UNSUPPORTED;
1780 goto CLOSE_PCIIO;
1781 }
1782 //
1783 // Determine if the device is UHCI or OHCI host controller or not. If yes, then find out the
1784 // companion usb ehci host controller and force EHCI driver get attached to it before
1785 // UHCI or OHCI driver attaches to UHCI or OHCI host controller.
1786 //
1787 if ((UsbClassCReg.ProgInterface == PCI_IF_UHCI || UsbClassCReg.ProgInterface == PCI_IF_OHCI) &&
1788 (UsbClassCReg.BaseCode == PCI_CLASS_SERIAL) &&
1789 (UsbClassCReg.SubClassCode == PCI_CLASS_SERIAL_USB)) {
1790 Status = PciIo->GetLocation (
1791 PciIo,
1792 &CompanionSegmentNumber,
1793 &CompanionBusNumber,
1794 &CompanionDeviceNumber,
1795 &CompanionFunctionNumber
1796 );
1797 if (EFI_ERROR (Status)) {
1798 goto CLOSE_PCIIO;
1799 }
1800
1801 Status = gBS->LocateHandleBuffer (
1802 ByProtocol,
1803 &gEfiPciIoProtocolGuid,
1804 NULL,
1805 &NumberOfHandles,
1806 &HandleBuffer
1807 );
1808 if (EFI_ERROR (Status)) {
1809 goto CLOSE_PCIIO;
1810 }
1811
1812 for (Index = 0; Index < NumberOfHandles; Index++) {
1813 //
1814 // Get the device path on this handle
1815 //
1816 Status = gBS->HandleProtocol (
1817 HandleBuffer[Index],
1818 &gEfiPciIoProtocolGuid,
1819 (VOID **)&Instance
1820 );
1821 ASSERT_EFI_ERROR (Status);
1822
1823 Status = Instance->Pci.Read (
1824 Instance,
1825 EfiPciIoWidthUint8,
1826 PCI_CLASSCODE_OFFSET,
1827 sizeof (USB_CLASSC) / sizeof (UINT8),
1828 &UsbClassCReg
1829 );
1830
1831 if (EFI_ERROR (Status)) {
1832 Status = EFI_UNSUPPORTED;
1833 goto CLOSE_PCIIO;
1834 }
1835
1836 if ((UsbClassCReg.ProgInterface == PCI_IF_EHCI) &&
1837 (UsbClassCReg.BaseCode == PCI_CLASS_SERIAL) &&
1838 (UsbClassCReg.SubClassCode == PCI_CLASS_SERIAL_USB)) {
1839 Status = Instance->GetLocation (
1840 Instance,
1841 &EhciSegmentNumber,
1842 &EhciBusNumber,
1843 &EhciDeviceNumber,
1844 &EhciFunctionNumber
1845 );
1846 if (EFI_ERROR (Status)) {
1847 goto CLOSE_PCIIO;
1848 }
1849 //
1850 // Currently, the judgment on the companion usb host controller is through the
1851 // same bus number, which may vary on different platform.
1852 //
1853 if (EhciBusNumber == CompanionBusNumber) {
1854 gBS->CloseProtocol (
1855 Controller,
1856 &gEfiPciIoProtocolGuid,
1857 This->DriverBindingHandle,
1858 Controller
1859 );
1860 EhcDriverBindingStart(This, HandleBuffer[Index], NULL);
1861 }
1862 }
1863 }
1864 Status = EFI_NOT_FOUND;
1865 goto CLOSE_PCIIO;
1866 }
1867
1868 //
1869 // Create then install USB2_HC_PROTOCOL
1870 //
1871 Ehc = EhcCreateUsb2Hc (PciIo, HcDevicePath, OriginalPciAttributes);
1872
1873 if (Ehc == NULL) {
1874 DEBUG ((EFI_D_ERROR, "EhcDriverBindingStart: failed to create USB2_HC\n"));
1875
1876 Status = EFI_OUT_OF_RESOURCES;
1877 goto CLOSE_PCIIO;
1878 }
1879
1880 //
1881 // Enable 64-bit DMA support in the PCI layer if this controller
1882 // supports it.
1883 //
1884 if (EHC_BIT_IS_SET (Ehc->HcCapParams, HCCP_64BIT)) {
1885 Status = PciIo->Attributes (
1886 PciIo,
1887 EfiPciIoAttributeOperationEnable,
1888 EFI_PCI_IO_ATTRIBUTE_DUAL_ADDRESS_CYCLE,
1889 NULL
1890 );
1891 if (!EFI_ERROR (Status)) {
1892 Ehc->Support64BitDma = TRUE;
1893 } else {
1894 DEBUG ((EFI_D_WARN,
1895 "%a: failed to enable 64-bit DMA on 64-bit capable controller @ %p (%r)\n",
1896 __FUNCTION__, Controller, Status));
1897 }
1898 }
1899
1900 Status = gBS->InstallProtocolInterface (
1901 &Controller,
1902 &gEfiUsb2HcProtocolGuid,
1903 EFI_NATIVE_INTERFACE,
1904 &Ehc->Usb2Hc
1905 );
1906
1907 if (EFI_ERROR (Status)) {
1908 DEBUG ((EFI_D_ERROR, "EhcDriverBindingStart: failed to install USB2_HC Protocol\n"));
1909 goto FREE_POOL;
1910 }
1911
1912 //
1913 // Robustnesss improvement such as for Duet platform
1914 // Default is not required.
1915 //
1916 if (FeaturePcdGet (PcdTurnOffUsbLegacySupport)) {
1917 EhcClearLegacySupport (Ehc);
1918 }
1919
1920 if (Ehc->DebugPortNum != 0) {
1921 State = EhcReadDbgRegister(Ehc, 0);
1922 if ((State & (USB_DEBUG_PORT_IN_USE | USB_DEBUG_PORT_OWNER)) != (USB_DEBUG_PORT_IN_USE | USB_DEBUG_PORT_OWNER)) {
1923 EhcResetHC (Ehc, EHC_RESET_TIMEOUT);
1924 }
1925 }
1926
1927 Status = EhcInitHC (Ehc);
1928
1929 if (EFI_ERROR (Status)) {
1930 DEBUG ((EFI_D_ERROR, "EhcDriverBindingStart: failed to init host controller\n"));
1931 goto UNINSTALL_USBHC;
1932 }
1933
1934 //
1935 // Start the asynchronous interrupt monitor
1936 //
1937 Status = gBS->SetTimer (Ehc->PollTimer, TimerPeriodic, EHC_ASYNC_POLL_INTERVAL);
1938
1939 if (EFI_ERROR (Status)) {
1940 DEBUG ((EFI_D_ERROR, "EhcDriverBindingStart: failed to start async interrupt monitor\n"));
1941
1942 EhcHaltHC (Ehc, EHC_GENERIC_TIMEOUT);
1943 goto UNINSTALL_USBHC;
1944 }
1945
1946 //
1947 // Create event to stop the HC when exit boot service.
1948 //
1949 Status = gBS->CreateEventEx (
1950 EVT_NOTIFY_SIGNAL,
1951 TPL_NOTIFY,
1952 EhcExitBootService,
1953 Ehc,
1954 &gEfiEventExitBootServicesGuid,
1955 &Ehc->ExitBootServiceEvent
1956 );
1957 if (EFI_ERROR (Status)) {
1958 goto UNINSTALL_USBHC;
1959 }
1960
1961 //
1962 // Install the component name protocol, don't fail the start
1963 // because of something for display.
1964 //
1965 AddUnicodeString2 (
1966 "eng",
1967 gEhciComponentName.SupportedLanguages,
1968 &Ehc->ControllerNameTable,
1969 L"Enhanced Host Controller (USB 2.0)",
1970 TRUE
1971 );
1972 AddUnicodeString2 (
1973 "en",
1974 gEhciComponentName2.SupportedLanguages,
1975 &Ehc->ControllerNameTable,
1976 L"Enhanced Host Controller (USB 2.0)",
1977 FALSE
1978 );
1979
1980
1981 DEBUG ((EFI_D_INFO, "EhcDriverBindingStart: EHCI started for controller @ %p\n", Controller));
1982 return EFI_SUCCESS;
1983
1984 UNINSTALL_USBHC:
1985 gBS->UninstallProtocolInterface (
1986 Controller,
1987 &gEfiUsb2HcProtocolGuid,
1988 &Ehc->Usb2Hc
1989 );
1990
1991 FREE_POOL:
1992 EhcFreeSched (Ehc);
1993 gBS->CloseEvent (Ehc->PollTimer);
1994 gBS->FreePool (Ehc);
1995
1996 CLOSE_PCIIO:
1997 if (PciAttributesSaved) {
1998 //
1999 // Restore original PCI attributes
2000 //
2001 PciIo->Attributes (
2002 PciIo,
2003 EfiPciIoAttributeOperationSet,
2004 OriginalPciAttributes,
2005 NULL
2006 );
2007 }
2008
2009 gBS->CloseProtocol (
2010 Controller,
2011 &gEfiPciIoProtocolGuid,
2012 This->DriverBindingHandle,
2013 Controller
2014 );
2015
2016 return Status;
2017 }
2018
2019
2020 /**
2021 Stop this driver on ControllerHandle. Support stopping any child handles
2022 created by this driver.
2023
2024 @param This Protocol instance pointer.
2025 @param Controller Handle of device to stop driver on.
2026 @param NumberOfChildren Number of Children in the ChildHandleBuffer.
2027 @param ChildHandleBuffer List of handles for the children we need to stop.
2028
2029 @return EFI_SUCCESS Success.
2030 @return EFI_DEVICE_ERROR Fail.
2031
2032 **/
2033 EFI_STATUS
2034 EFIAPI
2035 EhcDriverBindingStop (
2036 IN EFI_DRIVER_BINDING_PROTOCOL *This,
2037 IN EFI_HANDLE Controller,
2038 IN UINTN NumberOfChildren,
2039 IN EFI_HANDLE *ChildHandleBuffer
2040 )
2041 {
2042 EFI_STATUS Status;
2043 EFI_USB2_HC_PROTOCOL *Usb2Hc;
2044 EFI_PCI_IO_PROTOCOL *PciIo;
2045 USB2_HC_DEV *Ehc;
2046
2047 //
2048 // Test whether the Controller handler passed in is a valid
2049 // Usb controller handle that should be supported, if not,
2050 // return the error status directly
2051 //
2052 Status = gBS->OpenProtocol (
2053 Controller,
2054 &gEfiUsb2HcProtocolGuid,
2055 (VOID **) &Usb2Hc,
2056 This->DriverBindingHandle,
2057 Controller,
2058 EFI_OPEN_PROTOCOL_GET_PROTOCOL
2059 );
2060
2061 if (EFI_ERROR (Status)) {
2062 return Status;
2063 }
2064
2065 Ehc = EHC_FROM_THIS (Usb2Hc);
2066 PciIo = Ehc->PciIo;
2067
2068 Status = gBS->UninstallProtocolInterface (
2069 Controller,
2070 &gEfiUsb2HcProtocolGuid,
2071 Usb2Hc
2072 );
2073
2074 if (EFI_ERROR (Status)) {
2075 return Status;
2076 }
2077
2078 //
2079 // Stop AsyncRequest Polling timer then stop the EHCI driver
2080 // and uninstall the EHCI protocl.
2081 //
2082 gBS->SetTimer (Ehc->PollTimer, TimerCancel, EHC_ASYNC_POLL_INTERVAL);
2083 EhcHaltHC (Ehc, EHC_GENERIC_TIMEOUT);
2084
2085 if (Ehc->PollTimer != NULL) {
2086 gBS->CloseEvent (Ehc->PollTimer);
2087 }
2088
2089 if (Ehc->ExitBootServiceEvent != NULL) {
2090 gBS->CloseEvent (Ehc->ExitBootServiceEvent);
2091 }
2092
2093 EhcFreeSched (Ehc);
2094
2095 if (Ehc->ControllerNameTable != NULL) {
2096 FreeUnicodeStringTable (Ehc->ControllerNameTable);
2097 }
2098
2099 //
2100 // Disable routing of all ports to EHCI controller, so all ports are
2101 // routed back to the UHCI or OHCI controller.
2102 //
2103 EhcClearOpRegBit (Ehc, EHC_CONFIG_FLAG_OFFSET, CONFIGFLAG_ROUTE_EHC);
2104
2105 //
2106 // Restore original PCI attributes
2107 //
2108 PciIo->Attributes (
2109 PciIo,
2110 EfiPciIoAttributeOperationSet,
2111 Ehc->OriginalPciAttributes,
2112 NULL
2113 );
2114
2115 gBS->CloseProtocol (
2116 Controller,
2117 &gEfiPciIoProtocolGuid,
2118 This->DriverBindingHandle,
2119 Controller
2120 );
2121
2122 FreePool (Ehc);
2123
2124 return EFI_SUCCESS;
2125 }
2126
EFI Development Kit II mirror for PVE