]> git.proxmox.com Git - mirror_edk2.git/blob - QuarkSocPkg/QuarkSouthCluster/Usb/Ohci/Dxe/Ohci.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
QuarkSocPkg: Ohci/Dxe: remove set but unused variables
[mirror_edk2.git] / QuarkSocPkg / QuarkSouthCluster / Usb / Ohci / Dxe / Ohci.c
1 /** @file
2 This file contains the implementation of Usb Hc Protocol.
3
4 Copyright (c) 2013-2015 Intel Corporation.
5
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
10
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13
14 **/
15
16
17 #include "Ohci.h"
18
19 /**
20 Provides software reset for the USB host controller.
21
22 @param This This EFI_USB_HC_PROTOCOL instance.
23 @param Attributes A bit mask of the reset operation to perform.
24
25 @retval EFI_SUCCESS The reset operation succeeded.
26 @retval EFI_INVALID_PARAMETER Attributes is not valid.
27 @retval EFI_UNSUPPOURTED The type of reset specified by Attributes is
28 not currently supported by the host controller.
29 @retval EFI_DEVICE_ERROR Host controller isn't halted to reset.
30
31 **/
32 EFI_STATUS
33 EFIAPI
34 OhciReset (
35 IN EFI_USB_HC_PROTOCOL *This,
36 IN UINT16 Attributes
37 )
38 {
39 EFI_STATUS Status;
40 USB_OHCI_HC_DEV *Ohc;
41 UINT8 Index;
42 UINT8 NumOfPorts;
43 UINT32 PowerOnGoodTime;
44 UINT32 Data32;
45 BOOLEAN Flag = FALSE;
46
47 if ((Attributes & ~(EFI_USB_HC_RESET_GLOBAL | EFI_USB_HC_RESET_HOST_CONTROLLER)) != 0) {
48 return EFI_INVALID_PARAMETER;
49 }
50
51 Status = EFI_SUCCESS;
52 Ohc = USB_OHCI_HC_DEV_FROM_THIS (This);
53
54 if ((Attributes & EFI_USB_HC_RESET_HOST_CONTROLLER) != 0) {
55 gBS->Stall (50 * 1000);
56 Status = OhciSetHcCommandStatus (Ohc, HC_RESET, HC_RESET);
57 if (EFI_ERROR (Status)) {
58 return EFI_DEVICE_ERROR;
59 }
60 gBS->Stall (50 * 1000);
61 //
62 // Wait for host controller reset.
63 //
64 PowerOnGoodTime = 50;
65 do {
66 gBS->Stall (1 * 1000);
67 Data32 = OhciGetOperationalReg (Ohc->PciIo, HC_COMMAND_STATUS );
68 if (EFI_ERROR (Status)) {
69 return EFI_DEVICE_ERROR;
70 }
71 if ((Data32 & HC_RESET) == 0) {
72 Flag = TRUE;
73 break;
74 }
75 }while(PowerOnGoodTime--);
76 if (!Flag){
77 return EFI_DEVICE_ERROR;
78 }
79 }
80 OhciFreeIntTransferMemory (Ohc);
81 Status = OhciInitializeInterruptList (Ohc);
82 OhciSetFrameInterval (Ohc, FRAME_INTERVAL, 0x2edf);
83 if ((Attributes & EFI_USB_HC_RESET_GLOBAL) != 0) {
84 Status = OhciSetHcControl (Ohc, HC_FUNCTIONAL_STATE, HC_STATE_RESET);
85 if (EFI_ERROR (Status)) {
86 return EFI_DEVICE_ERROR;
87 }
88 gBS->Stall (50 * 1000);
89 }
90 //
91 // Initialize host controller operational registers
92 //
93 OhciSetFrameInterval (Ohc, FS_LARGEST_DATA_PACKET, 0x2778);
94 OhciSetFrameInterval (Ohc, FRAME_INTERVAL, 0x2edf);
95 OhciSetPeriodicStart (Ohc, 0x2a2f);
96 OhciSetHcControl (Ohc, CONTROL_BULK_RATIO, 0x3);
97 OhciSetHcCommandStatus (Ohc, CONTROL_LIST_FILLED | BULK_LIST_FILLED, 0);
98 OhciSetRootHubDescriptor (Ohc, RH_PSWITCH_MODE, 0);
99 OhciSetRootHubDescriptor (Ohc, RH_NO_PSWITCH | RH_NOC_PROT, 1);
100 //OhciSetRootHubDescriptor (Hc, RH_PSWITCH_MODE | RH_NO_PSWITCH, 0);
101 //OhciSetRootHubDescriptor (Hc, RH_PSWITCH_MODE | RH_NOC_PROT, 1);
102
103 OhciSetRootHubDescriptor (Ohc, RH_DEV_REMOVABLE, 0);
104 OhciSetRootHubDescriptor (Ohc, RH_PORT_PWR_CTRL_MASK, 0xffff);
105 OhciSetRootHubStatus (Ohc, RH_LOCAL_PSTAT_CHANGE);
106 OhciSetRootHubPortStatus (Ohc, 0, RH_SET_PORT_POWER);
107 OhciGetRootHubNumOfPorts (This, &NumOfPorts);
108 for (Index = 0; Index < NumOfPorts; Index++) {
109 if (!EFI_ERROR (OhciSetRootHubPortFeature (This, Index, EfiUsbPortReset))) {
110 gBS->Stall (200 * 1000);
111 OhciClearRootHubPortFeature (This, Index, EfiUsbPortReset);
112 gBS->Stall (1000);
113 OhciSetRootHubPortFeature (This, Index, EfiUsbPortEnable);
114 gBS->Stall (1000);
115 }
116 }
117 OhciSetMemoryPointer (Ohc, HC_HCCA, Ohc->HccaMemoryBlock);
118 OhciSetMemoryPointer (Ohc, HC_CONTROL_HEAD, NULL);
119 OhciSetMemoryPointer (Ohc, HC_BULK_HEAD, NULL);
120 OhciSetHcControl (Ohc, PERIODIC_ENABLE | CONTROL_ENABLE | BULK_ENABLE, 1); /*ISOCHRONOUS_ENABLE*/
121 OhciSetHcControl (Ohc, HC_FUNCTIONAL_STATE, HC_STATE_OPERATIONAL);
122 gBS->Stall (50*1000);
123 //
124 // Wait till first SOF occurs, and then clear it
125 //
126 while (OhciGetHcInterruptStatus (Ohc, START_OF_FRAME) == 0);
127 OhciClearInterruptStatus (Ohc, START_OF_FRAME);
128 gBS->Stall (1000);
129
130 return Status;
131 }
132
133 /**
134 Retrieve the current state of the USB host controller.
135
136 @param This This EFI_USB_HC_PROTOCOL instance.
137 @param State Variable to return the current host controller
138 state.
139
140 @retval EFI_SUCCESS Host controller state was returned in State.
141 @retval EFI_INVALID_PARAMETER State is NULL.
142 @retval EFI_DEVICE_ERROR An error was encountered while attempting to
143 retrieve the host controller's current state.
144
145 **/
146
147 EFI_STATUS
148 EFIAPI
149 OhciGetState (
150 IN EFI_USB_HC_PROTOCOL *This,
151 OUT EFI_USB_HC_STATE *State
152 )
153 {
154 USB_OHCI_HC_DEV *Ohc;
155 UINT32 FuncState;
156
157 if (State == NULL) {
158 return EFI_INVALID_PARAMETER;
159 }
160
161 Ohc = USB_OHCI_HC_DEV_FROM_THIS (This);
162
163 FuncState = OhciGetHcControl (Ohc, HC_FUNCTIONAL_STATE);
164
165 switch (FuncState) {
166 case HC_STATE_RESET:
167 case HC_STATE_RESUME:
168 *State = EfiUsbHcStateHalt;
169 break;
170
171 case HC_STATE_OPERATIONAL:
172 *State = EfiUsbHcStateOperational;
173 break;
174
175 case HC_STATE_SUSPEND:
176 *State = EfiUsbHcStateSuspend;
177 break;
178
179 default:
180 ASSERT (FALSE);
181 }
182 return EFI_SUCCESS;
183 }
184
185 /**
186 Sets the USB host controller to a specific state.
187
188 @param This This EFI_USB_HC_PROTOCOL instance.
189 @param State The state of the host controller that will be set.
190
191 @retval EFI_SUCCESS The USB host controller was successfully placed
192 in the state specified by State.
193 @retval EFI_INVALID_PARAMETER State is invalid.
194 @retval EFI_DEVICE_ERROR Failed to set the state due to device error.
195
196 **/
197
198 EFI_STATUS
199 EFIAPI
200 OhciSetState(
201 IN EFI_USB_HC_PROTOCOL *This,
202 IN EFI_USB_HC_STATE State
203 )
204 {
205 EFI_STATUS Status;
206 USB_OHCI_HC_DEV *Ohc;
207
208 Ohc = USB_OHCI_HC_DEV_FROM_THIS(This);
209
210 switch (State) {
211 case EfiUsbHcStateHalt:
212 Status = OhciSetHcControl (Ohc, HC_FUNCTIONAL_STATE, HC_STATE_RESET);
213 break;
214
215 case EfiUsbHcStateOperational:
216 Status = OhciSetHcControl (Ohc, HC_FUNCTIONAL_STATE, HC_STATE_OPERATIONAL);
217 break;
218
219 case EfiUsbHcStateSuspend:
220 Status = OhciSetHcControl (Ohc, HC_FUNCTIONAL_STATE, HC_STATE_SUSPEND);
221 break;
222
223 default:
224 Status = EFI_INVALID_PARAMETER;
225 }
226
227 gBS->Stall (1000);
228
229 return Status;
230 }
231
232 /**
233
234 Submits control transfer to a target USB device.
235
236 @param This A pointer to the EFI_USB_HC_PROTOCOL instance.
237 @param DeviceAddress Represents the address of the target device on the USB,
238 which is assigned during USB enumeration.
239 @param IsSlowDevice Indicates whether the target device is slow device
240 or full-speed device.
241 @param MaxPaketLength Indicates the maximum packet size that the
242 default control transfer endpoint is capable of
243 sending or receiving.
244 @param Request A pointer to the USB device request that will be sent
245 to the USB device.
246 @param TransferDirection Specifies the data direction for the transfer.
247 There are three values available, DataIn, DataOut
248 and NoData.
249 @param Data A pointer to the buffer of data that will be transmitted
250 to USB device or received from USB device.
251 @param DataLength Indicates the size, in bytes, of the data buffer
252 specified by Data.
253 @param TimeOut Indicates the maximum time, in microseconds,
254 which the transfer is allowed to complete.
255 @param TransferResult A pointer to the detailed result information generated
256 by this control transfer.
257
258 @retval EFI_SUCCESS The control transfer was completed successfully.
259 @retval EFI_OUT_OF_RESOURCES The control transfer could not be completed due to a lack of resources.
260 @retval EFI_INVALID_PARAMETER Some parameters are invalid.
261 @retval EFI_TIMEOUT The control transfer failed due to timeout.
262 @retval EFI_DEVICE_ERROR The control transfer failed due to host controller or device error.
263 Caller should check TranferResult for detailed error information.
264
265 --*/
266
267
268 EFI_STATUS
269 EFIAPI
270 OhciControlTransfer (
271 IN EFI_USB_HC_PROTOCOL *This,
272 IN UINT8 DeviceAddress,
273 IN BOOLEAN IsSlowDevice,
274 IN UINT8 MaxPacketLength,
275 IN EFI_USB_DEVICE_REQUEST *Request,
276 IN EFI_USB_DATA_DIRECTION TransferDirection,
277 IN OUT VOID *Data OPTIONAL,
278 IN OUT UINTN *DataLength OPTIONAL,
279 IN UINTN TimeOut,
280 OUT UINT32 *TransferResult
281 )
282 {
283 USB_OHCI_HC_DEV *Ohc;
284 ED_DESCRIPTOR *HeadEd;
285 ED_DESCRIPTOR *Ed;
286 TD_DESCRIPTOR *HeadTd;
287 TD_DESCRIPTOR *SetupTd;
288 TD_DESCRIPTOR *DataTd;
289 TD_DESCRIPTOR *StatusTd;
290 TD_DESCRIPTOR *EmptyTd;
291 EFI_STATUS Status;
292 UINT32 DataPidDir;
293 UINT32 StatusPidDir;
294 UINTN TimeCount;
295 OHCI_ED_RESULT EdResult;
296
297 EFI_PCI_IO_PROTOCOL_OPERATION MapOp;
298
299 UINTN ActualSendLength;
300 UINTN LeftLength;
301 UINT8 DataToggle;
302
303 VOID *ReqMapping = NULL;
304 UINTN ReqMapLength = 0;
305 EFI_PHYSICAL_ADDRESS ReqMapPhyAddr = 0;
306
307 VOID *DataMapping = NULL;
308 UINTN DataMapLength = 0;
309 EFI_PHYSICAL_ADDRESS DataMapPhyAddr = 0;
310
311 HeadTd = NULL;
312 DataTd = NULL;
313
314 if ((TransferDirection != EfiUsbDataOut && TransferDirection != EfiUsbDataIn &&
315 TransferDirection != EfiUsbNoData) ||
316 Request == NULL || DataLength == NULL || TransferResult == NULL ||
317 (TransferDirection == EfiUsbNoData && (*DataLength != 0 || Data != NULL)) ||
318 (TransferDirection != EfiUsbNoData && (*DataLength == 0 || Data == NULL)) ||
319 (IsSlowDevice && MaxPacketLength != 8) ||
320 (MaxPacketLength != 8 && MaxPacketLength != 16 &&
321 MaxPacketLength != 32 && MaxPacketLength != 64)) {
322 return EFI_INVALID_PARAMETER;
323 }
324
325 if (*DataLength > MAX_BYTES_PER_TD) {
326 DEBUG ((EFI_D_ERROR, "OhciControlTransfer: Request data size is too large\r\n"));
327 return EFI_INVALID_PARAMETER;
328 }
329
330 Ohc = USB_OHCI_HC_DEV_FROM_THIS(This);
331
332 if (TransferDirection == EfiUsbDataIn) {
333 DataPidDir = TD_IN_PID;
334 StatusPidDir = TD_OUT_PID;
335 } else {
336 DataPidDir = TD_OUT_PID;
337 StatusPidDir = TD_IN_PID;
338 }
339
340 Status = OhciSetHcControl (Ohc, CONTROL_ENABLE, 0);
341 if (EFI_ERROR(Status)) {
342 DEBUG ((EFI_D_INFO, "OhciControlTransfer: fail to disable CONTROL_ENABLE\r\n"));
343 *TransferResult = EFI_USB_ERR_SYSTEM;
344 return EFI_DEVICE_ERROR;
345 }
346 Status = OhciSetHcCommandStatus (Ohc, CONTROL_LIST_FILLED, 0);
347 if (EFI_ERROR(Status)) {
348 DEBUG ((EFI_D_INFO, "OhciControlTransfer: fail to disable CONTROL_LIST_FILLED\r\n"));
349 *TransferResult = EFI_USB_ERR_SYSTEM;
350 return EFI_DEVICE_ERROR;
351 }
352 gBS->Stall(20 * 1000);
353
354 OhciSetMemoryPointer (Ohc, HC_CONTROL_HEAD, NULL);
355 Ed = OhciCreateED (Ohc);
356 if (Ed == NULL) {
357 Status = EFI_OUT_OF_RESOURCES;
358 DEBUG ((EFI_D_INFO, "OhciControlTransfer: Fail to allocate ED buffer\r\n"));
359 goto CTRL_EXIT;
360 }
361 OhciSetEDField (Ed, ED_SKIP, 1);
362 OhciSetEDField (Ed, ED_FUNC_ADD, DeviceAddress);
363 OhciSetEDField (Ed, ED_ENDPT_NUM, 0);
364 OhciSetEDField (Ed, ED_DIR, ED_FROM_TD_DIR);
365 OhciSetEDField (Ed, ED_SPEED, IsSlowDevice);
366 OhciSetEDField (Ed, ED_FORMAT | ED_HALTED | ED_DTTOGGLE, 0);
367 OhciSetEDField (Ed, ED_MAX_PACKET, MaxPacketLength);
368 OhciSetEDField (Ed, ED_PDATA, 0);
369 OhciSetEDField (Ed, ED_ZERO, 0);
370 OhciSetEDField (Ed, ED_TDHEAD_PTR, 0);
371 OhciSetEDField (Ed, ED_TDTAIL_PTR, 0);
372 OhciSetEDField (Ed, ED_NEXT_EDPTR, 0);
373 HeadEd = OhciAttachEDToList (Ohc, CONTROL_LIST, Ed, NULL);
374 //
375 // Setup Stage
376 //
377 if(Request != NULL) {
378 ReqMapLength = sizeof(EFI_USB_DEVICE_REQUEST);
379 MapOp = EfiPciIoOperationBusMasterRead;
380 Status = Ohc->PciIo->Map (Ohc->PciIo, MapOp, (UINT8 *)Request, &ReqMapLength, &ReqMapPhyAddr, &ReqMapping);
381 if (EFI_ERROR(Status)) {
382 DEBUG ((EFI_D_INFO, "OhciControlTransfer: Fail to Map Request Buffer\r\n"));
383 goto FREE_ED_BUFF;
384 }
385 }
386 SetupTd = OhciCreateTD (Ohc);
387 if (SetupTd == NULL) {
388 Status = EFI_OUT_OF_RESOURCES;
389 DEBUG ((EFI_D_INFO, "OhciControlTransfer: Fail to allocate Setup TD buffer\r\n"));
390 goto UNMAP_SETUP_BUFF;
391 }
392 HeadTd = SetupTd;
393 OhciSetTDField (SetupTd, TD_PDATA, 0);
394 OhciSetTDField (SetupTd, TD_BUFFER_ROUND, 1);
395 OhciSetTDField (SetupTd, TD_DIR_PID, TD_SETUP_PID);
396 OhciSetTDField (SetupTd, TD_DELAY_INT, TD_NO_DELAY);
397 OhciSetTDField (SetupTd, TD_DT_TOGGLE, 2);
398 OhciSetTDField (SetupTd, TD_ERROR_CNT, 0);
399 OhciSetTDField (SetupTd, TD_COND_CODE, TD_TOBE_PROCESSED);
400 OhciSetTDField (SetupTd, TD_CURR_BUFFER_PTR, (UINT32)ReqMapPhyAddr);
401 OhciSetTDField (SetupTd, TD_NEXT_PTR, 0);
402 OhciSetTDField (SetupTd, TD_BUFFER_END_PTR, (UINT32)(ReqMapPhyAddr + sizeof (EFI_USB_DEVICE_REQUEST) - 1));
403 SetupTd->ActualSendLength = sizeof (EFI_USB_DEVICE_REQUEST);
404 SetupTd->DataBuffer = (UINT32)ReqMapPhyAddr;
405 SetupTd->NextTDPointer = 0;
406
407 if (TransferDirection == EfiUsbDataIn) {
408 MapOp = EfiPciIoOperationBusMasterWrite;
409 } else {
410 MapOp = EfiPciIoOperationBusMasterRead;
411 }
412 DataMapLength = *DataLength;
413 if ((Data != NULL) && (DataMapLength != 0)) {
414 Status = Ohc->PciIo->Map (Ohc->PciIo, MapOp, Data, &DataMapLength, &DataMapPhyAddr, &DataMapping);
415 if (EFI_ERROR(Status)) {
416 DEBUG ((EFI_D_INFO, "OhciControlTransfer: Fail To Map Data Buffer\r\n"));
417 goto FREE_TD_BUFF;
418 }
419 }
420 //
421 //Data Stage
422 //
423 LeftLength = DataMapLength;
424 ActualSendLength = DataMapLength;
425 DataToggle = 1;
426 while (LeftLength > 0) {
427 ActualSendLength = LeftLength;
428 if (LeftLength > MaxPacketLength) {
429 ActualSendLength = MaxPacketLength;
430 }
431 DataTd = OhciCreateTD (Ohc);
432 if (DataTd == NULL) {
433 DEBUG ((EFI_D_INFO, "OhciControlTransfer: Fail to allocate buffer for Data Stage TD\r\n"));
434 Status = EFI_OUT_OF_RESOURCES;
435 goto UNMAP_DATA_BUFF;
436 }
437 OhciSetTDField (DataTd, TD_PDATA, 0);
438 OhciSetTDField (DataTd, TD_BUFFER_ROUND, 1);
439 OhciSetTDField (DataTd, TD_DIR_PID, DataPidDir);
440 OhciSetTDField (DataTd, TD_DELAY_INT, TD_NO_DELAY);
441 OhciSetTDField (DataTd, TD_DT_TOGGLE, DataToggle);
442 OhciSetTDField (DataTd, TD_ERROR_CNT, 0);
443 OhciSetTDField (DataTd, TD_COND_CODE, TD_TOBE_PROCESSED);
444 OhciSetTDField (DataTd, TD_CURR_BUFFER_PTR, (UINT32) DataMapPhyAddr);
445 OhciSetTDField (DataTd, TD_BUFFER_END_PTR, (UINT32)(DataMapPhyAddr + ActualSendLength - 1));
446 OhciSetTDField (DataTd, TD_NEXT_PTR, 0);
447 DataTd->ActualSendLength = (UINT32)ActualSendLength;
448 DataTd->DataBuffer = (UINT32)DataMapPhyAddr;
449 DataTd->NextTDPointer = 0;
450 OhciLinkTD (HeadTd, DataTd);
451 DataToggle ^= 1;
452 DataMapPhyAddr += ActualSendLength;
453 LeftLength -= ActualSendLength;
454 }
455 //
456 // Status Stage
457 //
458 StatusTd = OhciCreateTD (Ohc);
459 if (StatusTd == NULL) {
460 DEBUG ((EFI_D_INFO, "OhciControlTransfer: Fail to allocate buffer for Status Stage TD\r\n"));
461 Status = EFI_OUT_OF_RESOURCES;
462 goto UNMAP_DATA_BUFF;
463 }
464 OhciSetTDField (StatusTd, TD_PDATA, 0);
465 OhciSetTDField (StatusTd, TD_BUFFER_ROUND, 1);
466 OhciSetTDField (StatusTd, TD_DIR_PID, StatusPidDir);
467 OhciSetTDField (StatusTd, TD_DELAY_INT, 7);
468 OhciSetTDField (StatusTd, TD_DT_TOGGLE, 3);
469 OhciSetTDField (StatusTd, TD_ERROR_CNT, 0);
470 OhciSetTDField (StatusTd, TD_COND_CODE, TD_TOBE_PROCESSED);
471 OhciSetTDField (StatusTd, TD_CURR_BUFFER_PTR, 0);
472 OhciSetTDField (StatusTd, TD_NEXT_PTR, 0);
473 OhciSetTDField (StatusTd, TD_BUFFER_END_PTR, 0);
474 StatusTd->ActualSendLength = 0;
475 StatusTd->DataBuffer = 0;
476 StatusTd->NextTDPointer = 0;
477 OhciLinkTD (HeadTd, StatusTd);
478 //
479 // Empty Stage
480 //
481 EmptyTd = OhciCreateTD (Ohc);
482 if (EmptyTd == NULL) {
483 Status = EFI_OUT_OF_RESOURCES;
484 goto UNMAP_DATA_BUFF;
485 }
486 OhciSetTDField (EmptyTd, TD_PDATA, 0);
487 OhciSetTDField (EmptyTd, TD_BUFFER_ROUND, 0);
488 OhciSetTDField (EmptyTd, TD_DIR_PID, 0);
489 OhciSetTDField (EmptyTd, TD_DELAY_INT, 0);
490 //OhciSetTDField (EmptyTd, TD_DT_TOGGLE, CurrentToggle);
491 EmptyTd->Word0.DataToggle = 0;
492 OhciSetTDField (EmptyTd, TD_ERROR_CNT, 0);
493 OhciSetTDField (EmptyTd, TD_COND_CODE, 0);
494 OhciSetTDField (EmptyTd, TD_CURR_BUFFER_PTR, 0);
495 OhciSetTDField (EmptyTd, TD_BUFFER_END_PTR, 0);
496 OhciSetTDField (EmptyTd, TD_NEXT_PTR, 0);
497 EmptyTd->ActualSendLength = 0;
498 EmptyTd->DataBuffer = 0;
499 EmptyTd->NextTDPointer = 0;
500 OhciLinkTD (HeadTd, EmptyTd);
501 Ed->TdTailPointer = (UINT32)(UINTN)EmptyTd;
502 OhciAttachTDListToED (Ed, HeadTd);
503 //
504 // For debugging, dump ED & TD buffer befor transferring
505 //
506 //
507 //OhciDumpEdTdInfo (Ohc, Ed, HeadTd, TRUE);
508 //
509 OhciSetEDField (Ed, ED_SKIP, 0);
510 Status = OhciSetHcControl (Ohc, CONTROL_ENABLE, 1);
511 if (EFI_ERROR(Status)) {
512 DEBUG ((EFI_D_INFO, "OhciControlTransfer: fail to enable CONTROL_ENABLE\r\n"));
513 *TransferResult = EFI_USB_ERR_SYSTEM;
514 Status = EFI_DEVICE_ERROR;
515 goto UNMAP_DATA_BUFF;
516 }
517 Status = OhciSetHcCommandStatus (Ohc, CONTROL_LIST_FILLED, 1);
518 if (EFI_ERROR(Status)) {
519 DEBUG ((EFI_D_INFO, "OhciControlTransfer: fail to enable CONTROL_LIST_FILLED\r\n"));
520 *TransferResult = EFI_USB_ERR_SYSTEM;
521 Status = EFI_DEVICE_ERROR;
522 goto UNMAP_DATA_BUFF;
523 }
524 gBS->Stall(20 * 1000);
525
526
527 TimeCount = 0;
528 Status = CheckIfDone (Ohc, CONTROL_LIST, Ed, HeadTd, &EdResult);
529
530 while (Status == EFI_NOT_READY && TimeCount <= TimeOut) {
531 gBS->Stall (1000);
532 TimeCount++;
533 Status = CheckIfDone (Ohc, CONTROL_LIST, Ed, HeadTd, &EdResult);
534 }
535 //
536 // For debugging, dump ED & TD buffer after transferring
537 //
538 //OhciDumpEdTdInfo (Ohc, Ed, HeadTd, FALSE);
539 //
540 *TransferResult = ConvertErrorCode (EdResult.ErrorCode);
541
542 if (EdResult.ErrorCode != TD_NO_ERROR) {
543 if (EdResult.ErrorCode == TD_TOBE_PROCESSED) {
544 DEBUG ((EFI_D_INFO, "Control pipe timeout, > %d mS\r\n", TimeOut));
545 } else {
546 DEBUG ((EFI_D_INFO, "Control pipe broken\r\n"));
547 }
548 *DataLength = 0;
549 } else {
550 DEBUG ((EFI_D_INFO, "Control transfer successed\r\n"));
551 }
552
553 UNMAP_DATA_BUFF:
554 OhciSetEDField (Ed, ED_SKIP, 1);
555 if (HeadEd == Ed) {
556 OhciSetMemoryPointer (Ohc, HC_CONTROL_HEAD, NULL);
557 } else {
558 HeadEd->NextED = Ed->NextED;
559 }
560 if(DataMapping != NULL) {
561 Ohc->PciIo->Unmap(Ohc->PciIo, DataMapping);
562 }
563
564 FREE_TD_BUFF:
565 while (HeadTd) {
566 DataTd = HeadTd;
567 HeadTd = (TD_DESCRIPTOR *)(UINTN)(HeadTd->NextTDPointer);
568 UsbHcFreeMem(Ohc->MemPool, DataTd, sizeof(TD_DESCRIPTOR));
569 }
570
571 UNMAP_SETUP_BUFF:
572 if(ReqMapping != NULL) {
573 Ohc->PciIo->Unmap(Ohc->PciIo, ReqMapping);
574 }
575
576 FREE_ED_BUFF:
577 UsbHcFreeMem(Ohc->MemPool, Ed, sizeof(ED_DESCRIPTOR));
578
579 CTRL_EXIT:
580 return Status;
581 }
582
583 /**
584
585 Submits bulk transfer to a bulk endpoint of a USB device.
586
587 @param This A pointer to the EFI_USB_HC_PROTOCOL instance.
588 @param DeviceAddress Represents the address of the target device on the USB,
589 which is assigned during USB enumeration.
590 @param EndPointAddress The combination of an endpoint number and an
591 endpoint direction of the target USB device.
592 Each endpoint address supports data transfer in
593 one direction except the control endpoint
594 (whose default endpoint address is 0).
595 It is the caller's responsibility to make sure that
596 the EndPointAddress represents a bulk endpoint.
597 @param MaximumPacketLength Indicates the maximum packet size the target endpoint
598 is capable of sending or receiving.
599 @param Data A pointer to the buffer of data that will be transmitted
600 to USB device or received from USB device.
601 @param DataLength When input, indicates the size, in bytes, of the data buffer
602 specified by Data. When output, indicates the actually
603 transferred data size.
604 @param DataToggle A pointer to the data toggle value. On input, it indicates
605 the initial data toggle value the bulk transfer should adopt;
606 on output, it is updated to indicate the data toggle value
607 of the subsequent bulk transfer.
608 @param TimeOut Indicates the maximum time, in microseconds, which the
609 transfer is allowed to complete.
610 TransferResult A pointer to the detailed result information of the
611 bulk transfer.
612
613 @retval EFI_SUCCESS The bulk transfer was completed successfully.
614 @retval EFI_OUT_OF_RESOURCES The bulk transfer could not be submitted due to lack of resource.
615 @retval EFI_INVALID_PARAMETER Some parameters are invalid.
616 @retval EFI_TIMEOUT The bulk transfer failed due to timeout.
617 @retval EFI_DEVICE_ERROR The bulk transfer failed due to host controller or device error.
618 Caller should check TranferResult for detailed error information.
619
620 **/
621
622
623 EFI_STATUS
624 EFIAPI
625 OhciBulkTransfer(
626 IN EFI_USB_HC_PROTOCOL *This,
627 IN UINT8 DeviceAddress,
628 IN UINT8 EndPointAddress,
629 IN UINT8 MaxPacketLength,
630 IN OUT VOID *Data,
631 IN OUT UINTN *DataLength,
632 IN OUT UINT8 *DataToggle,
633 IN UINTN TimeOut,
634 OUT UINT32 *TransferResult
635 )
636 {
637 USB_OHCI_HC_DEV *Ohc;
638 ED_DESCRIPTOR *HeadEd;
639 ED_DESCRIPTOR *Ed;
640 UINT32 DataPidDir;
641 TD_DESCRIPTOR *HeadTd;
642 TD_DESCRIPTOR *DataTd;
643 TD_DESCRIPTOR *EmptyTd;
644 EFI_STATUS Status;
645 UINT8 EndPointNum;
646 UINTN TimeCount;
647 OHCI_ED_RESULT EdResult;
648
649 EFI_PCI_IO_PROTOCOL_OPERATION MapOp;
650 VOID *Mapping;
651 UINTN MapLength;
652 EFI_PHYSICAL_ADDRESS MapPyhAddr;
653 UINTN LeftLength;
654 UINTN ActualSendLength;
655 BOOLEAN FirstTD;
656
657 Mapping = NULL;
658 MapLength = 0;
659 MapPyhAddr = 0;
660 LeftLength = 0;
661 Status = EFI_SUCCESS;
662
663 if (Data == NULL || DataLength == NULL || DataToggle == NULL || TransferResult == NULL ||
664 *DataLength == 0 || (*DataToggle != 0 && *DataToggle != 1) ||
665 (MaxPacketLength != 8 && MaxPacketLength != 16 &&
666 MaxPacketLength != 32 && MaxPacketLength != 64)) {
667 return EFI_INVALID_PARAMETER;
668 }
669
670 Ohc = USB_OHCI_HC_DEV_FROM_THIS (This);
671
672 if ((EndPointAddress & 0x80) != 0) {
673 DataPidDir = TD_IN_PID;
674 MapOp = EfiPciIoOperationBusMasterWrite;
675 } else {
676 DataPidDir = TD_OUT_PID;
677 MapOp = EfiPciIoOperationBusMasterRead;
678 }
679
680 EndPointNum = (EndPointAddress & 0xF);
681 EdResult.NextToggle = *DataToggle;
682
683 Status = OhciSetHcControl (Ohc, BULK_ENABLE, 0);
684 if (EFI_ERROR(Status)) {
685 DEBUG ((EFI_D_INFO, "OhciControlTransfer: fail to disable BULK_ENABLE\r\n"));
686 *TransferResult = EFI_USB_ERR_SYSTEM;
687 return EFI_DEVICE_ERROR;
688 }
689 Status = OhciSetHcCommandStatus (Ohc, BULK_LIST_FILLED, 0);
690 if (EFI_ERROR(Status)) {
691 DEBUG ((EFI_D_INFO, "OhciControlTransfer: fail to disable BULK_LIST_FILLED\r\n"));
692 *TransferResult = EFI_USB_ERR_SYSTEM;
693 return EFI_DEVICE_ERROR;
694 }
695 gBS->Stall(20 * 1000);
696
697 OhciSetMemoryPointer (Ohc, HC_BULK_HEAD, NULL);
698
699 Ed = OhciCreateED (Ohc);
700 if (Ed == NULL) {
701 return EFI_OUT_OF_RESOURCES;
702 }
703 OhciSetEDField (Ed, ED_SKIP, 1);
704 OhciSetEDField (Ed, ED_FUNC_ADD, DeviceAddress);
705 OhciSetEDField (Ed, ED_ENDPT_NUM, EndPointNum);
706 OhciSetEDField (Ed, ED_DIR, ED_FROM_TD_DIR);
707 OhciSetEDField (Ed, ED_SPEED, HI_SPEED);
708 OhciSetEDField (Ed, ED_FORMAT | ED_HALTED | ED_DTTOGGLE, 0);
709 OhciSetEDField (Ed, ED_MAX_PACKET, MaxPacketLength);
710 OhciSetEDField (Ed, ED_PDATA, 0);
711 OhciSetEDField (Ed, ED_ZERO, 0);
712 OhciSetEDField (Ed, ED_TDHEAD_PTR, 0);
713 OhciSetEDField (Ed, ED_TDTAIL_PTR, 0);
714 OhciSetEDField (Ed, ED_NEXT_EDPTR, 0);
715 HeadEd = OhciAttachEDToList (Ohc, BULK_LIST, Ed, NULL);
716
717 if(Data != NULL) {
718 MapLength = *DataLength;
719 Status = Ohc->PciIo->Map (Ohc->PciIo, MapOp, (UINT8 *)Data, &MapLength, &MapPyhAddr, &Mapping);
720 if (EFI_ERROR(Status)) {
721 DEBUG ((EFI_D_INFO, "OhciBulkTransfer: Fail to Map Data Buffer for Bulk\r\n"));
722 goto FREE_ED_BUFF;
723 }
724 }
725 //
726 //Data Stage
727 //
728 LeftLength = MapLength;
729 ActualSendLength = MapLength;
730 HeadTd = NULL;
731 FirstTD = TRUE;
732 while (LeftLength > 0) {
733 ActualSendLength = LeftLength;
734 if (LeftLength > MaxPacketLength) {
735 ActualSendLength = MaxPacketLength;
736 }
737 DataTd = OhciCreateTD (Ohc);
738 if (DataTd == NULL) {
739 DEBUG ((EFI_D_INFO, "OhciBulkTransfer: Fail to allocate buffer for Data Stage TD\r\n"));
740 Status = EFI_OUT_OF_RESOURCES;
741 goto FREE_OHCI_TDBUFF;
742 }
743 OhciSetTDField (DataTd, TD_PDATA, 0);
744 OhciSetTDField (DataTd, TD_BUFFER_ROUND, 1);
745 OhciSetTDField (DataTd, TD_DIR_PID, DataPidDir);
746 OhciSetTDField (DataTd, TD_DELAY_INT, TD_NO_DELAY);
747 OhciSetTDField (DataTd, TD_DT_TOGGLE, *DataToggle);
748 OhciSetTDField (DataTd, TD_ERROR_CNT, 0);
749 OhciSetTDField (DataTd, TD_COND_CODE, TD_TOBE_PROCESSED);
750 OhciSetTDField (DataTd, TD_CURR_BUFFER_PTR, (UINT32) MapPyhAddr);
751 OhciSetTDField (DataTd, TD_BUFFER_END_PTR, (UINT32)(MapPyhAddr + ActualSendLength - 1));
752 OhciSetTDField (DataTd, TD_NEXT_PTR, 0);
753 DataTd->ActualSendLength = (UINT32)ActualSendLength;
754 DataTd->DataBuffer = (UINT32)MapPyhAddr;
755 DataTd->NextTDPointer = 0;
756 if (FirstTD) {
757 HeadTd = DataTd;
758 FirstTD = FALSE;
759 } else {
760 OhciLinkTD (HeadTd, DataTd);
761 }
762 *DataToggle ^= 1;
763 MapPyhAddr += ActualSendLength;
764 LeftLength -= ActualSendLength;
765 }
766 //
767 // Empty Stage
768 //
769 EmptyTd = OhciCreateTD (Ohc);
770 if (EmptyTd == NULL) {
771 Status = EFI_OUT_OF_RESOURCES;
772 DEBUG ((EFI_D_INFO, "OhciBulkTransfer: Fail to allocate buffer for Empty TD\r\n"));
773 goto FREE_OHCI_TDBUFF;
774 }
775 OhciSetTDField (EmptyTd, TD_PDATA, 0);
776 OhciSetTDField (EmptyTd, TD_BUFFER_ROUND, 0);
777 OhciSetTDField (EmptyTd, TD_DIR_PID, 0);
778 OhciSetTDField (EmptyTd, TD_DELAY_INT, 0);
779 //OhciSetTDField (EmptyTd, TD_DT_TOGGLE, CurrentToggle);
780 EmptyTd->Word0.DataToggle = 0;
781 OhciSetTDField (EmptyTd, TD_ERROR_CNT, 0);
782 OhciSetTDField (EmptyTd, TD_COND_CODE, 0);
783 OhciSetTDField (EmptyTd, TD_CURR_BUFFER_PTR, 0);
784 OhciSetTDField (EmptyTd, TD_BUFFER_END_PTR, 0);
785 OhciSetTDField (EmptyTd, TD_NEXT_PTR, 0);
786 EmptyTd->ActualSendLength = 0;
787 EmptyTd->DataBuffer = 0;
788 EmptyTd->NextTDPointer = 0;
789 OhciLinkTD (HeadTd, EmptyTd);
790 Ed->TdTailPointer = (UINT32)(UINTN)EmptyTd;
791 OhciAttachTDListToED (Ed, HeadTd);
792
793 OhciSetEDField (Ed, ED_SKIP, 0);
794 Status = OhciSetHcCommandStatus (Ohc, BULK_LIST_FILLED, 1);
795 if (EFI_ERROR(Status)) {
796 *TransferResult = EFI_USB_ERR_SYSTEM;
797 Status = EFI_DEVICE_ERROR;
798 DEBUG ((EFI_D_INFO, "OhciControlTransfer: Fail to enable BULK_LIST_FILLED\r\n"));
799 goto FREE_OHCI_TDBUFF;
800 }
801 Status = OhciSetHcControl (Ohc, BULK_ENABLE, 1);
802 if (EFI_ERROR(Status)) {
803 *TransferResult = EFI_USB_ERR_SYSTEM;
804 Status = EFI_DEVICE_ERROR;
805 DEBUG ((EFI_D_INFO, "OhciControlTransfer: Fail to enable BULK_ENABLE\r\n"));
806 goto FREE_OHCI_TDBUFF;
807 }
808 gBS->Stall(20 * 1000);
809
810 TimeCount = 0;
811 Status = CheckIfDone (Ohc, BULK_LIST, Ed, HeadTd, &EdResult);
812 while (Status == EFI_NOT_READY && TimeCount <= TimeOut) {
813 gBS->Stall (1000);
814 TimeCount++;
815 Status = CheckIfDone (Ohc, BULK_LIST, Ed, HeadTd, &EdResult);
816 }
817
818 *TransferResult = ConvertErrorCode (EdResult.ErrorCode);
819
820 if (EdResult.ErrorCode != TD_NO_ERROR) {
821 if (EdResult.ErrorCode == TD_TOBE_PROCESSED) {
822 DEBUG ((EFI_D_INFO, "Bulk pipe timeout, > %d mS\r\n", TimeOut));
823 } else {
824 DEBUG ((EFI_D_INFO, "Bulk pipe broken\r\n"));
825 *DataToggle = EdResult.NextToggle;
826 }
827 *DataLength = 0;
828 } else {
829 DEBUG ((EFI_D_INFO, "Bulk transfer successed\r\n"));
830 }
831 //*DataToggle = (UINT8) OhciGetEDField (Ed, ED_DTTOGGLE);
832
833 FREE_OHCI_TDBUFF:
834 OhciSetEDField (Ed, ED_SKIP, 1);
835 if (HeadEd == Ed) {
836 OhciSetMemoryPointer (Ohc, HC_BULK_HEAD, NULL);
837 }else {
838 HeadEd->NextED = Ed->NextED;
839 }
840 while (HeadTd) {
841 DataTd = HeadTd;
842 HeadTd = (TD_DESCRIPTOR *)(UINTN)(HeadTd->NextTDPointer);
843 UsbHcFreeMem(Ohc->MemPool, DataTd, sizeof(TD_DESCRIPTOR));
844 }
845
846 if(Mapping != NULL) {
847 Ohc->PciIo->Unmap(Ohc->PciIo, Mapping);
848 }
849
850 FREE_ED_BUFF:
851 UsbHcFreeMem(Ohc->MemPool, Ed, sizeof(ED_DESCRIPTOR));
852
853 return Status;
854 }
855 /**
856
857 Submits an interrupt transfer to an interrupt endpoint of a USB device.
858
859 @param Ohc Device private data
860 @param DeviceAddress Represents the address of the target device on the USB,
861 which is assigned during USB enumeration.
862 @param EndPointAddress The combination of an endpoint number and an endpoint
863 direction of the target USB device. Each endpoint address
864 supports data transfer in one direction except the
865 control endpoint (whose default endpoint address is 0).
866 It is the caller's responsibility to make sure that
867 the EndPointAddress represents an interrupt endpoint.
868 @param IsSlowDevice Indicates whether the target device is slow device
869 or full-speed device.
870 @param MaxPacketLength Indicates the maximum packet size the target endpoint
871 is capable of sending or receiving.
872 @param IsNewTransfer If TRUE, an asynchronous interrupt pipe is built between
873 the host and the target interrupt endpoint.
874 If FALSE, the specified asynchronous interrupt pipe
875 is canceled.
876 @param DataToggle A pointer to the data toggle value. On input, it is valid
877 when IsNewTransfer is TRUE, and it indicates the initial
878 data toggle value the asynchronous interrupt transfer
879 should adopt.
880 On output, it is valid when IsNewTransfer is FALSE,
881 and it is updated to indicate the data toggle value of
882 the subsequent asynchronous interrupt transfer.
883 @param PollingInterval Indicates the interval, in milliseconds, that the
884 asynchronous interrupt transfer is polled.
885 This parameter is required when IsNewTransfer is TRUE.
886 @param UCBuffer Uncacheable buffer
887 @param DataLength Indicates the length of data to be received at the
888 rate specified by PollingInterval from the target
889 asynchronous interrupt endpoint. This parameter
890 is only required when IsNewTransfer is TRUE.
891 @param CallBackFunction The Callback function.This function is called at the
892 rate specified by PollingInterval.This parameter is
893 only required when IsNewTransfer is TRUE.
894 @param Context The context that is passed to the CallBackFunction.
895 This is an optional parameter and may be NULL.
896 @param IsPeriodic Periodic interrupt or not
897 @param OutputED The correspoding ED carried out
898 @param OutputTD The correspoding TD carried out
899
900
901 @retval EFI_SUCCESS The asynchronous interrupt transfer request has been successfully
902 submitted or canceled.
903 @retval EFI_INVALID_PARAMETER Some parameters are invalid.
904 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources.
905
906 **/
907
908 EFI_STATUS
909 OhciInterruptTransfer (
910 IN USB_OHCI_HC_DEV *Ohc,
911 IN UINT8 DeviceAddress,
912 IN UINT8 EndPointAddress,
913 IN BOOLEAN IsSlowDevice,
914 IN UINT8 MaxPacketLength,
915 IN BOOLEAN IsNewTransfer,
916 IN OUT UINT8 *DataToggle OPTIONAL,
917 IN UINTN PollingInterval OPTIONAL,
918 IN VOID *UCBuffer OPTIONAL,
919 IN UINTN DataLength OPTIONAL,
920 IN EFI_ASYNC_USB_TRANSFER_CALLBACK CallBackFunction OPTIONAL,
921 IN VOID *Context OPTIONAL,
922 IN BOOLEAN IsPeriodic OPTIONAL,
923 OUT ED_DESCRIPTOR **OutputED OPTIONAL,
924 OUT TD_DESCRIPTOR **OutputTD OPTIONAL
925 )
926 {
927 ED_DESCRIPTOR *Ed;
928 UINT8 EdDir;
929 ED_DESCRIPTOR *HeadEd;
930 TD_DESCRIPTOR *HeadTd;
931 TD_DESCRIPTOR *DataTd;
932 TD_DESCRIPTOR *EmptTd;
933 UINTN Depth;
934 UINTN Index;
935 EFI_STATUS Status;
936 UINT8 EndPointNum;
937 UINT32 DataPidDir;
938 INTERRUPT_CONTEXT_ENTRY *Entry;
939 EFI_TPL OldTpl;
940 BOOLEAN FirstTD;
941
942 VOID *Mapping;
943 UINTN MapLength;
944 EFI_PHYSICAL_ADDRESS MapPyhAddr;
945 UINTN LeftLength;
946 UINTN ActualSendLength;
947
948
949 if (DataLength > MAX_BYTES_PER_TD) {
950 DEBUG ((EFI_D_ERROR, "OhciInterruptTransfer: Error param\r\n"));
951 return EFI_INVALID_PARAMETER;
952 }
953
954 if ((EndPointAddress & 0x80) != 0) {
955 EdDir = ED_IN_DIR;
956 DataPidDir = TD_IN_PID;
957 } else {
958 EdDir = ED_OUT_DIR;
959 DataPidDir = TD_OUT_PID;
960 }
961
962 EndPointNum = (EndPointAddress & 0xF);
963
964 if (!IsNewTransfer) {
965 OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
966 OhciSetHcControl (Ohc, PERIODIC_ENABLE, 0);
967 OhciFreeInterruptContext (Ohc, DeviceAddress, EndPointAddress, DataToggle);
968 Status = OhciFreeInterruptEdByAddr (Ohc, DeviceAddress, EndPointNum);
969 OhciSetHcControl (Ohc, PERIODIC_ENABLE, 1);
970 gBS->RestoreTPL (OldTpl);
971 return Status;
972 }
973 MapLength = DataLength;
974 Status = Ohc->PciIo->Map(
975 Ohc->PciIo,
976 EfiPciIoOperationBusMasterWrite,
977 UCBuffer,
978 &MapLength,
979 &MapPyhAddr,
980 &Mapping
981 );
982 if (EFI_ERROR (Status)) {
983 DEBUG ((EFI_D_ERROR, "OhciInterruptTransfer: Failt to PciIo->Map buffer \r\n"));
984 goto EXIT;
985 }
986 Depth = 5;
987 Index = 1;
988 while (PollingInterval >= Index * 2 && Depth > 0) {
989 Index *= 2;
990 Depth--;
991 }
992 //
993 //ED Stage
994 //
995 HeadEd = OhciFindMinInterruptEDList (Ohc, (UINT32)Depth);
996 if ((Ed = OhciFindWorkingEd (HeadEd, DeviceAddress, EndPointNum, EdDir)) != NULL) {
997 OhciSetEDField (Ed, ED_SKIP, 1);
998 } else {
999 Ed = OhciCreateED (Ohc);
1000 if (Ed == NULL) {
1001 Status = EFI_OUT_OF_RESOURCES;
1002 DEBUG ((EFI_D_ERROR, "OhciInterruptTransfer: Fail to allocate buffer for ED\r\n"));
1003 goto UNMAP_OHCI_XBUFF;
1004 }
1005 OhciSetEDField (Ed, ED_SKIP, 1);
1006 OhciSetEDField (Ed, ED_FUNC_ADD, DeviceAddress);
1007 OhciSetEDField (Ed, ED_ENDPT_NUM, EndPointNum);
1008 OhciSetEDField (Ed, ED_DIR, ED_FROM_TD_DIR);
1009 OhciSetEDField (Ed, ED_SPEED, IsSlowDevice);
1010 OhciSetEDField (Ed, ED_FORMAT, 0);
1011 OhciSetEDField (Ed, ED_MAX_PACKET, MaxPacketLength);
1012 OhciSetEDField (Ed, ED_PDATA | ED_ZERO | ED_HALTED | ED_DTTOGGLE, 0);
1013 OhciSetEDField (Ed, ED_TDHEAD_PTR, 0);
1014 OhciSetEDField (Ed, ED_TDTAIL_PTR, 0);
1015 OhciSetEDField (Ed, ED_NEXT_EDPTR, 0);
1016 OhciAttachEDToList (Ohc, INTERRUPT_LIST, Ed, HeadEd);
1017 }
1018 //
1019 //Data Stage
1020 //
1021 LeftLength = MapLength;
1022 ActualSendLength = MapLength;
1023 HeadTd = NULL;
1024 FirstTD = TRUE;
1025 while (LeftLength > 0) {
1026 ActualSendLength = LeftLength;
1027 if (LeftLength > MaxPacketLength) {
1028 ActualSendLength = MaxPacketLength;
1029 }
1030 DataTd = OhciCreateTD (Ohc);
1031 if (DataTd == NULL) {
1032 Status = EFI_OUT_OF_RESOURCES;
1033 DEBUG ((EFI_D_ERROR, "OhciInterruptTransfer: Fail to allocate buffer for Data Stage TD\r\n"));
1034 goto FREE_OHCI_TDBUFF;
1035 }
1036 OhciSetTDField (DataTd, TD_PDATA, 0);
1037 OhciSetTDField (DataTd, TD_BUFFER_ROUND, 1);
1038 OhciSetTDField (DataTd, TD_DIR_PID, DataPidDir);
1039 OhciSetTDField (DataTd, TD_DELAY_INT, TD_NO_DELAY);
1040 OhciSetTDField (DataTd, TD_DT_TOGGLE, *DataToggle);
1041 OhciSetTDField (DataTd, TD_ERROR_CNT, 0);
1042 OhciSetTDField (DataTd, TD_COND_CODE, TD_TOBE_PROCESSED);
1043 OhciSetTDField (DataTd, TD_CURR_BUFFER_PTR, (UINT32) MapPyhAddr);
1044 OhciSetTDField (DataTd, TD_BUFFER_END_PTR, (UINT32)(MapPyhAddr + ActualSendLength - 1));
1045 OhciSetTDField (DataTd, TD_NEXT_PTR, 0);
1046 DataTd->ActualSendLength = (UINT32)ActualSendLength;
1047 DataTd->DataBuffer = (UINT32)MapPyhAddr;
1048 DataTd->NextTDPointer = 0;
1049 if (FirstTD) {
1050 HeadTd = DataTd;
1051 FirstTD = FALSE;
1052 } else {
1053 OhciLinkTD (HeadTd, DataTd);
1054 }
1055 *DataToggle ^= 1;
1056 MapPyhAddr += ActualSendLength;
1057 LeftLength -= ActualSendLength;
1058 }
1059
1060 EmptTd = OhciCreateTD (Ohc);
1061 if (EmptTd == NULL) {
1062 Status = EFI_OUT_OF_RESOURCES;
1063 DEBUG ((EFI_D_ERROR, "OhciInterruptTransfer: Fail to allocate buffer for Empty Stage TD\r\n"));
1064 goto FREE_OHCI_TDBUFF;
1065 }
1066 OhciSetTDField (EmptTd, TD_PDATA, 0);
1067 OhciSetTDField (EmptTd, TD_BUFFER_ROUND, 0);
1068 OhciSetTDField (EmptTd, TD_DIR_PID, 0);
1069 OhciSetTDField (EmptTd, TD_DELAY_INT, 0);
1070 //OhciSetTDField (EmptTd, TD_DT_TOGGLE, CurrentToggle);
1071 EmptTd->Word0.DataToggle = 0;
1072 OhciSetTDField (EmptTd, TD_ERROR_CNT, 0);
1073 OhciSetTDField (EmptTd, TD_COND_CODE, 0);
1074 OhciSetTDField (EmptTd, TD_CURR_BUFFER_PTR, 0);
1075 OhciSetTDField (EmptTd, TD_BUFFER_END_PTR, 0);
1076 OhciSetTDField (EmptTd, TD_NEXT_PTR, 0);
1077 EmptTd->ActualSendLength = 0;
1078 EmptTd->DataBuffer = 0;
1079 EmptTd->NextTDPointer = 0;
1080 OhciLinkTD (HeadTd, EmptTd);
1081 Ed->TdTailPointer = (UINT32)(UINTN)EmptTd;
1082 OhciAttachTDListToED (Ed, HeadTd);
1083
1084 if (OutputED != NULL) {
1085 *OutputED = Ed;
1086 }
1087 if (OutputTD != NULL) {
1088 *OutputTD = HeadTd;
1089 }
1090
1091 if (CallBackFunction != NULL) {
1092 Entry = AllocatePool (sizeof (INTERRUPT_CONTEXT_ENTRY));
1093 if (Entry == NULL) {
1094 goto FREE_OHCI_TDBUFF;
1095 }
1096
1097 Entry->DeviceAddress = DeviceAddress;
1098 Entry->EndPointAddress = EndPointAddress;
1099 Entry->Ed = Ed;
1100 Entry->DataTd = HeadTd;
1101 Entry->IsSlowDevice = IsSlowDevice;
1102 Entry->MaxPacketLength = MaxPacketLength;
1103 Entry->PollingInterval = PollingInterval;
1104 Entry->CallBackFunction = CallBackFunction;
1105 Entry->Context = Context;
1106 Entry->IsPeriodic = IsPeriodic;
1107 Entry->UCBuffer = UCBuffer;
1108 Entry->UCBufferMapping = Mapping;
1109 Entry->DataLength = DataLength;
1110 Entry->Toggle = DataToggle;
1111 Entry->NextEntry = NULL;
1112 OhciAddInterruptContextEntry (Ohc, Entry);
1113 }
1114 OhciSetEDField (Ed, ED_SKIP, 0);
1115
1116 if (OhciGetHcControl (Ohc, PERIODIC_ENABLE) == 0) {
1117 Status = OhciSetHcControl (Ohc, PERIODIC_ENABLE, 1);
1118 gBS->Stall (1000);
1119 }
1120
1121 return EFI_SUCCESS;
1122
1123 FREE_OHCI_TDBUFF:
1124 while (HeadTd) {
1125 DataTd = HeadTd;
1126 HeadTd = (TD_DESCRIPTOR *)(UINTN)(HeadTd->NextTDPointer);
1127 UsbHcFreeMem(Ohc->MemPool, DataTd, sizeof(TD_DESCRIPTOR));
1128 }
1129
1130 //FREE_OHCI_EDBUFF:
1131 if ((HeadEd != Ed) && HeadEd && Ed) {
1132 while(HeadEd->NextED != (UINT32)(UINTN)Ed) {
1133 HeadEd = (ED_DESCRIPTOR *)(UINTN)(HeadEd->NextED);
1134 }
1135 HeadEd->NextED = Ed->NextED;
1136 UsbHcFreeMem(Ohc->MemPool, Ed, sizeof(ED_DESCRIPTOR));
1137 }
1138
1139 UNMAP_OHCI_XBUFF:
1140 Ohc->PciIo->Unmap(Ohc->PciIo, Mapping);
1141
1142 EXIT:
1143 return Status;
1144 }
1145
1146 /**
1147
1148 Submits an asynchronous interrupt transfer to an interrupt endpoint of a USB device.
1149
1150 @param This A pointer to the EFI_USB_HC_PROTOCOL instance.
1151 @param DeviceAddress Represents the address of the target device on the USB,
1152 which is assigned during USB enumeration.
1153 @param EndPointAddress The combination of an endpoint number and an endpoint
1154 direction of the target USB device. Each endpoint address
1155 supports data transfer in one direction except the
1156 control endpoint (whose default endpoint address is 0).
1157 It is the caller's responsibility to make sure that
1158 the EndPointAddress represents an interrupt endpoint.
1159 @param IsSlowDevice Indicates whether the target device is slow device
1160 or full-speed device.
1161 @param MaxiumPacketLength Indicates the maximum packet size the target endpoint
1162 is capable of sending or receiving.
1163 @param IsNewTransfer If TRUE, an asynchronous interrupt pipe is built between
1164 the host and the target interrupt endpoint.
1165 If FALSE, the specified asynchronous interrupt pipe
1166 is canceled.
1167 @param DataToggle A pointer to the data toggle value. On input, it is valid
1168 when IsNewTransfer is TRUE, and it indicates the initial
1169 data toggle value the asynchronous interrupt transfer
1170 should adopt.
1171 On output, it is valid when IsNewTransfer is FALSE,
1172 and it is updated to indicate the data toggle value of
1173 the subsequent asynchronous interrupt transfer.
1174 @param PollingInterval Indicates the interval, in milliseconds, that the
1175 asynchronous interrupt transfer is polled.
1176 This parameter is required when IsNewTransfer is TRUE.
1177 @param DataLength Indicates the length of data to be received at the
1178 rate specified by PollingInterval from the target
1179 asynchronous interrupt endpoint. This parameter
1180 is only required when IsNewTransfer is TRUE.
1181 @param CallBackFunction The Callback function.This function is called at the
1182 rate specified by PollingInterval.This parameter is
1183 only required when IsNewTransfer is TRUE.
1184 @param Context The context that is passed to the CallBackFunction.
1185 This is an optional parameter and may be NULL.
1186
1187 @retval EFI_SUCCESS The asynchronous interrupt transfer request has been successfully
1188 submitted or canceled.
1189 @retval EFI_INVALID_PARAMETER Some parameters are invalid.
1190 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources.
1191
1192 **/
1193
1194
1195 EFI_STATUS
1196 EFIAPI
1197 OhciAsyncInterruptTransfer (
1198 IN EFI_USB_HC_PROTOCOL *This,
1199 IN UINT8 DeviceAddress,
1200 IN UINT8 EndPointAddress,
1201 IN BOOLEAN IsSlowDevice,
1202 IN UINT8 MaxPacketLength,
1203 IN BOOLEAN IsNewTransfer,
1204 IN OUT UINT8 *DataToggle OPTIONAL,
1205 IN UINTN PollingInterval OPTIONAL,
1206 IN UINTN DataLength OPTIONAL,
1207 IN EFI_ASYNC_USB_TRANSFER_CALLBACK CallBackFunction OPTIONAL,
1208 IN VOID *Context OPTIONAL
1209 )
1210 {
1211 EFI_STATUS Status;
1212 USB_OHCI_HC_DEV *Ohc;
1213 VOID *UCBuffer;
1214
1215 if (DataToggle == NULL || (EndPointAddress & 0x80) == 0 ||
1216 (IsNewTransfer && (DataLength == 0 ||
1217 (*DataToggle != 0 && *DataToggle != 1) || (PollingInterval < 1 || PollingInterval > 255)))) {
1218 return EFI_INVALID_PARAMETER;
1219 }
1220
1221 Ohc = USB_OHCI_HC_DEV_FROM_THIS (This);
1222 if ( IsNewTransfer ) {
1223 UCBuffer = AllocatePool(DataLength);
1224 if (UCBuffer == NULL) {
1225 return EFI_OUT_OF_RESOURCES;
1226 }
1227 } else {
1228 UCBuffer = NULL;
1229 }
1230 Status = OhciInterruptTransfer (
1231 Ohc,
1232 DeviceAddress,
1233 EndPointAddress,
1234 IsSlowDevice,
1235 MaxPacketLength,
1236 IsNewTransfer,
1237 DataToggle,
1238 PollingInterval,
1239 UCBuffer,
1240 DataLength,
1241 CallBackFunction,
1242 Context,
1243 TRUE,
1244 NULL,
1245 NULL
1246 );
1247 if ( IsNewTransfer ) {
1248 if (EFI_ERROR(Status)) {
1249 gBS->FreePool (UCBuffer);
1250 }
1251 }
1252 return Status;
1253 }
1254
1255
1256 /**
1257
1258 Submits synchronous interrupt transfer to an interrupt endpoint
1259 of a USB device.
1260
1261 @param This A pointer to the EFI_USB_HC_PROTOCOL instance.
1262 @param DeviceAddress Represents the address of the target device on the USB,
1263 which is assigned during USB enumeration.
1264 @param EndPointAddress The combination of an endpoint number and an endpoint
1265 direction of the target USB device. Each endpoint
1266 address supports data transfer in one direction
1267 except the control endpoint (whose default
1268 endpoint address is 0). It is the caller's responsibility
1269 to make sure that the EndPointAddress represents
1270 an interrupt endpoint.
1271 @param IsSlowDevice Indicates whether the target device is slow device
1272 or full-speed device.
1273 @param MaxPacketLength Indicates the maximum packet size the target endpoint
1274 is capable of sending or receiving.
1275 @param Data A pointer to the buffer of data that will be transmitted
1276 to USB device or received from USB device.
1277 @param DataLength On input, the size, in bytes, of the data buffer specified
1278 by Data. On output, the number of bytes transferred.
1279 @param DataToggle A pointer to the data toggle value. On input, it indicates
1280 the initial data toggle value the synchronous interrupt
1281 transfer should adopt;
1282 on output, it is updated to indicate the data toggle value
1283 of the subsequent synchronous interrupt transfer.
1284 @param TimeOut Indicates the maximum time, in microseconds, which the
1285 transfer is allowed to complete.
1286 @param TransferResult A pointer to the detailed result information from
1287 the synchronous interrupt transfer.
1288
1289 @retval EFI_UNSUPPORTED This interface not available.
1290 @retval EFI_INVALID_PARAMETER Parameters not follow spec
1291
1292 **/
1293
1294
1295 EFI_STATUS
1296 EFIAPI
1297 OhciSyncInterruptTransfer (
1298 IN EFI_USB_HC_PROTOCOL *This,
1299 IN UINT8 DeviceAddress,
1300 IN UINT8 EndPointAddress,
1301 IN BOOLEAN IsSlowDevice,
1302 IN UINT8 MaxPacketLength,
1303 IN OUT VOID *Data,
1304 IN OUT UINTN *DataLength,
1305 IN OUT UINT8 *DataToggle,
1306 IN UINTN TimeOut,
1307 OUT UINT32 *TransferResult
1308 )
1309 {
1310 USB_OHCI_HC_DEV *Ohc;
1311 EFI_STATUS Status;
1312 ED_DESCRIPTOR *Ed;
1313 TD_DESCRIPTOR *HeadTd;
1314 OHCI_ED_RESULT EdResult;
1315 VOID *UCBuffer;
1316
1317 if ((EndPointAddress & 0x80) == 0 || Data == NULL || DataLength == NULL || *DataLength == 0 ||
1318 (IsSlowDevice && MaxPacketLength > 8) || (!IsSlowDevice && MaxPacketLength > 64) ||
1319 DataToggle == NULL || (*DataToggle != 0 && *DataToggle != 1) || TransferResult == NULL) {
1320 return EFI_INVALID_PARAMETER;
1321 }
1322
1323 Ohc = USB_OHCI_HC_DEV_FROM_THIS (This);
1324 UCBuffer = AllocatePool (*DataLength);
1325 if (UCBuffer == NULL) {
1326 return EFI_OUT_OF_RESOURCES;
1327 }
1328 Status = OhciInterruptTransfer (
1329 Ohc,
1330 DeviceAddress,
1331 EndPointAddress,
1332 IsSlowDevice,
1333 MaxPacketLength,
1334 TRUE,
1335 DataToggle,
1336 1,
1337 UCBuffer,
1338 *DataLength,
1339 NULL,
1340 NULL,
1341 FALSE,
1342 &Ed,
1343 &HeadTd
1344 );
1345
1346 if (!EFI_ERROR (Status)) {
1347 Status = CheckIfDone (Ohc, INTERRUPT_LIST, Ed, HeadTd, &EdResult);
1348 while (Status == EFI_NOT_READY && TimeOut > 0) {
1349 gBS->Stall (1000);
1350 TimeOut--;
1351 Status = CheckIfDone (Ohc, INTERRUPT_LIST, Ed, HeadTd, &EdResult);
1352 }
1353
1354 *TransferResult = ConvertErrorCode (EdResult.ErrorCode);
1355 }
1356 CopyMem(Data, UCBuffer, *DataLength);
1357 Status = OhciInterruptTransfer (
1358 Ohc,
1359 DeviceAddress,
1360 EndPointAddress,
1361 IsSlowDevice,
1362 MaxPacketLength,
1363 FALSE,
1364 DataToggle,
1365 0,
1366 NULL,
1367 0,
1368 NULL,
1369 NULL,
1370 FALSE,
1371 NULL,
1372 NULL
1373 );
1374
1375 return Status;
1376 }
1377 /**
1378
1379 Submits isochronous transfer to a target USB device.
1380
1381 @param This A pointer to the EFI_USB_HC_PROTOCOL instance.
1382 @param DeviceAddress Represents the address of the target device on the USB,
1383 which is assigned during USB enumeration.
1384 @param EndPointAddress End point address
1385 @param MaximumPacketLength Indicates the maximum packet size that the
1386 default control transfer endpoint is capable of
1387 sending or receiving.
1388 @param Data A pointer to the buffer of data that will be transmitted
1389 to USB device or received from USB device.
1390 @param DataLength Indicates the size, in bytes, of the data buffer
1391 specified by Data.
1392 @param TransferResult A pointer to the detailed result information generated
1393 by this control transfer.
1394
1395 @retval EFI_UNSUPPORTED This interface not available
1396 @retval EFI_INVALID_PARAMETER Data is NULL or DataLength is 0 or TransferResult is NULL
1397
1398 **/
1399
1400
1401 EFI_STATUS
1402 EFIAPI
1403 OhciIsochronousTransfer (
1404 IN EFI_USB_HC_PROTOCOL *This,
1405 IN UINT8 DeviceAddress,
1406 IN UINT8 EndPointAddress,
1407 IN UINT8 MaximumPacketLength,
1408 IN OUT VOID *Data,
1409 IN OUT UINTN DataLength,
1410 OUT UINT32 *TransferResult
1411 )
1412 {
1413 if (Data == NULL || DataLength == 0 || TransferResult == NULL) {
1414 return EFI_INVALID_PARAMETER;
1415 }
1416
1417 return EFI_UNSUPPORTED;
1418 }
1419
1420 /**
1421
1422 Submits Async isochronous transfer to a target USB device.
1423
1424 @param his A pointer to the EFI_USB_HC_PROTOCOL instance.
1425 @param DeviceAddress Represents the address of the target device on the USB,
1426 which is assigned during USB enumeration.
1427 @param EndPointAddress End point address
1428 @param MaximumPacketLength Indicates the maximum packet size that the
1429 default control transfer endpoint is capable of
1430 sending or receiving.
1431 @param Data A pointer to the buffer of data that will be transmitted
1432 to USB device or received from USB device.
1433 @param IsochronousCallBack When the transfer complete, the call back function will be called
1434 @param Context Pass to the call back function as parameter
1435
1436 @retval EFI_UNSUPPORTED This interface not available
1437 @retval EFI_INVALID_PARAMETER Data is NULL or Datalength is 0
1438
1439 **/
1440
1441 EFI_STATUS
1442 EFIAPI
1443 OhciAsyncIsochronousTransfer (
1444 IN EFI_USB_HC_PROTOCOL *This,
1445 IN UINT8 DeviceAddress,
1446 IN UINT8 EndPointAddress,
1447 IN UINT8 MaximumPacketLength,
1448 IN OUT VOID *Data,
1449 IN OUT UINTN DataLength,
1450 IN EFI_ASYNC_USB_TRANSFER_CALLBACK IsochronousCallBack,
1451 IN VOID *Context OPTIONAL
1452 )
1453 {
1454
1455 if (Data == NULL || DataLength == 0) {
1456 return EFI_INVALID_PARAMETER;
1457 }
1458
1459 return EFI_UNSUPPORTED;
1460 }
1461
1462 /**
1463
1464 Retrieves the number of root hub ports.
1465
1466 @param This A pointer to the EFI_USB_HC_PROTOCOL instance.
1467 @param NumOfPorts A pointer to the number of the root hub ports.
1468
1469 @retval EFI_SUCCESS The port number was retrieved successfully.
1470 **/
1471 EFI_STATUS
1472 EFIAPI
1473 OhciGetRootHubNumOfPorts (
1474 IN EFI_USB_HC_PROTOCOL *This,
1475 OUT UINT8 *NumOfPorts
1476 )
1477 {
1478 USB_OHCI_HC_DEV *Ohc;
1479 Ohc = USB_OHCI_HC_DEV_FROM_THIS (This);
1480
1481 if (NumOfPorts == NULL) {
1482 return EFI_INVALID_PARAMETER;
1483 }
1484
1485 *NumOfPorts = (UINT8)OhciGetRootHubDescriptor(Ohc, RH_NUM_DS_PORTS);
1486
1487 return EFI_SUCCESS;
1488 }
1489 /**
1490
1491 Retrieves the current status of a USB root hub port.
1492
1493 @param This A pointer to the EFI_USB_HC_PROTOCOL.
1494 @param PortNumber Specifies the root hub port from which the status
1495 is to be retrieved. This value is zero-based. For example,
1496 if a root hub has two ports, then the first port is numbered 0,
1497 and the second port is numbered 1.
1498 @param PortStatus A pointer to the current port status bits and
1499 port status change bits.
1500
1501 @retval EFI_SUCCESS The status of the USB root hub port specified by PortNumber
1502 was returned in PortStatus.
1503 @retval EFI_INVALID_PARAMETER Port number not valid
1504 **/
1505
1506
1507 EFI_STATUS
1508 EFIAPI
1509 OhciGetRootHubPortStatus (
1510 IN EFI_USB_HC_PROTOCOL *This,
1511 IN UINT8 PortNumber,
1512 OUT EFI_USB_PORT_STATUS *PortStatus
1513 )
1514 {
1515 USB_OHCI_HC_DEV *Ohc;
1516 UINT8 NumOfPorts;
1517
1518 Ohc = USB_OHCI_HC_DEV_FROM_THIS (This);
1519
1520 OhciGetRootHubNumOfPorts (This, &NumOfPorts);
1521 if (PortNumber >= NumOfPorts) {
1522 return EFI_INVALID_PARAMETER;
1523 }
1524 PortStatus->PortStatus = 0;
1525 PortStatus->PortChangeStatus = 0;
1526
1527 if (OhciReadRootHubPortStatus (Ohc,PortNumber, RH_CURR_CONNECT_STAT)) {
1528 PortStatus->PortStatus |= USB_PORT_STAT_CONNECTION;
1529 }
1530 if (OhciReadRootHubPortStatus (Ohc,PortNumber, RH_PORT_ENABLE_STAT)) {
1531 PortStatus->PortStatus |= USB_PORT_STAT_ENABLE;
1532 }
1533 if (OhciReadRootHubPortStatus (Ohc,PortNumber, RH_PORT_SUSPEND_STAT)) {
1534 PortStatus->PortStatus |= USB_PORT_STAT_SUSPEND;
1535 }
1536 if (OhciReadRootHubPortStatus (Ohc,PortNumber, RH_PORT_OC_INDICATOR)) {
1537 PortStatus->PortStatus |= USB_PORT_STAT_OVERCURRENT;
1538 }
1539 if (OhciReadRootHubPortStatus (Ohc,PortNumber, RH_PORT_RESET_STAT)) {
1540 PortStatus->PortStatus |= USB_PORT_STAT_RESET;
1541 }
1542 if (OhciReadRootHubPortStatus (Ohc,PortNumber, RH_PORT_POWER_STAT)) {
1543 PortStatus->PortStatus |= USB_PORT_STAT_POWER;
1544 }
1545 if (OhciReadRootHubPortStatus (Ohc,PortNumber, RH_LSDEVICE_ATTACHED)) {
1546 PortStatus->PortStatus |= USB_PORT_STAT_LOW_SPEED;
1547 }
1548 if (OhciReadRootHubPortStatus (Ohc, PortNumber, RH_PORT_ENABLE_STAT_CHANGE)) {
1549 PortStatus->PortChangeStatus |= USB_PORT_STAT_C_ENABLE;
1550 }
1551 if (OhciReadRootHubPortStatus (Ohc, PortNumber, RH_CONNECT_STATUS_CHANGE)) {
1552 PortStatus->PortChangeStatus |= USB_PORT_STAT_C_CONNECTION;
1553 }
1554 if (OhciReadRootHubPortStatus (Ohc, PortNumber, RH_PORT_SUSPEND_STAT_CHANGE)) {
1555 PortStatus->PortChangeStatus |= USB_PORT_STAT_C_SUSPEND;
1556 }
1557 if (OhciReadRootHubPortStatus (Ohc, PortNumber, RH_OC_INDICATOR_CHANGE)) {
1558 PortStatus->PortChangeStatus |= USB_PORT_STAT_C_OVERCURRENT;
1559 }
1560 if (OhciReadRootHubPortStatus (Ohc, PortNumber, RH_PORT_RESET_STAT_CHANGE)) {
1561 PortStatus->PortChangeStatus |= USB_PORT_STAT_C_RESET;
1562 }
1563
1564 return EFI_SUCCESS;
1565 }
1566 /**
1567
1568 Sets a feature for the specified root hub port.
1569
1570 @param This A pointer to the EFI_USB_HC_PROTOCOL.
1571 @param PortNumber Specifies the root hub port whose feature
1572 is requested to be set.
1573 @param PortFeature Indicates the feature selector associated
1574 with the feature set request.
1575
1576 @retval EFI_SUCCESS The feature specified by PortFeature was set for the
1577 USB root hub port specified by PortNumber.
1578 @retval EFI_DEVICE_ERROR Set feature failed because of hardware issue
1579 @retval EFI_INVALID_PARAMETER PortNumber is invalid or PortFeature is invalid.
1580 **/
1581 EFI_STATUS
1582 EFIAPI
1583 OhciSetRootHubPortFeature (
1584 IN EFI_USB_HC_PROTOCOL *This,
1585 IN UINT8 PortNumber,
1586 IN EFI_USB_PORT_FEATURE PortFeature
1587 )
1588 {
1589 USB_OHCI_HC_DEV *Ohc;
1590 EFI_STATUS Status;
1591 UINT8 NumOfPorts;
1592 UINTN RetryTimes;
1593
1594 OhciGetRootHubNumOfPorts (This, &NumOfPorts);
1595 if (PortNumber >= NumOfPorts) {
1596 return EFI_INVALID_PARAMETER;
1597 }
1598
1599 Ohc = USB_OHCI_HC_DEV_FROM_THIS (This);
1600
1601 Status = EFI_SUCCESS;
1602
1603
1604 switch (PortFeature) {
1605 case EfiUsbPortPower:
1606 Status = OhciSetRootHubPortStatus (Ohc, PortNumber, RH_SET_PORT_POWER);
1607
1608 //
1609 // Verify the state
1610 //
1611 RetryTimes = 0;
1612 do {
1613 gBS->Stall (1000);
1614 RetryTimes++;
1615 } while (OhciReadRootHubPortStatus (Ohc, PortNumber, RH_PORT_POWER_STAT) == 0 &&
1616 RetryTimes < MAX_RETRY_TIMES);
1617
1618 if (RetryTimes >= MAX_RETRY_TIMES) {
1619 return EFI_DEVICE_ERROR;
1620 }
1621 break;
1622
1623 case EfiUsbPortReset:
1624 Status = OhciSetRootHubPortStatus (Ohc, PortNumber, RH_SET_PORT_RESET);
1625
1626 //
1627 // Verify the state
1628 //
1629 RetryTimes = 0;
1630 do {
1631 gBS->Stall (1000);
1632 RetryTimes++;
1633 } while ((OhciReadRootHubPortStatus (Ohc, PortNumber, RH_PORT_RESET_STAT_CHANGE) == 0 ||
1634 OhciReadRootHubPortStatus (Ohc, PortNumber, RH_PORT_RESET_STAT) == 1) &&
1635 RetryTimes < MAX_RETRY_TIMES);
1636
1637 if (RetryTimes >= MAX_RETRY_TIMES) {
1638 return EFI_DEVICE_ERROR;
1639 }
1640
1641 OhciSetRootHubPortStatus (Ohc, PortNumber, RH_PORT_RESET_STAT_CHANGE);
1642 break;
1643
1644 case EfiUsbPortEnable:
1645 Status = OhciSetRootHubPortStatus (Ohc, PortNumber, RH_SET_PORT_ENABLE);
1646
1647 //
1648 // Verify the state
1649 //
1650 RetryTimes = 0;
1651 do {
1652 gBS->Stall (1000);
1653 RetryTimes++;
1654 } while (OhciReadRootHubPortStatus (Ohc, PortNumber, RH_PORT_ENABLE_STAT) == 0 &&
1655 RetryTimes < MAX_RETRY_TIMES);
1656
1657 if (RetryTimes >= MAX_RETRY_TIMES) {
1658 return EFI_DEVICE_ERROR;
1659 }
1660 break;
1661
1662
1663 case EfiUsbPortSuspend:
1664 Status = OhciSetRootHubPortStatus (Ohc, PortNumber, RH_SET_PORT_SUSPEND);
1665
1666 //
1667 // Verify the state
1668 //
1669 RetryTimes = 0;
1670 do {
1671 gBS->Stall (1000);
1672 RetryTimes++;
1673 } while (OhciReadRootHubPortStatus (Ohc, PortNumber, RH_PORT_SUSPEND_STAT) == 0 &&
1674 RetryTimes < MAX_RETRY_TIMES);
1675
1676 if (RetryTimes >= MAX_RETRY_TIMES) {
1677 return EFI_DEVICE_ERROR;
1678 }
1679 break;
1680
1681 default:
1682 return EFI_INVALID_PARAMETER;
1683 }
1684
1685 return Status;
1686 }
1687
1688 /**
1689
1690 Clears a feature for the specified root hub port.
1691
1692 @param This A pointer to the EFI_USB_HC_PROTOCOL instance.
1693 @param PortNumber Specifies the root hub port whose feature
1694 is requested to be cleared.
1695 @param PortFeature Indicates the feature selector associated with the
1696 feature clear request.
1697
1698 @retval EFI_SUCCESS The feature specified by PortFeature was cleared for the
1699 USB root hub port specified by PortNumber.
1700 @retval EFI_INVALID_PARAMETER PortNumber is invalid or PortFeature is invalid.
1701 @retval EFI_DEVICE_ERROR Some error happened when clearing feature
1702 **/
1703 EFI_STATUS
1704 EFIAPI
1705 OhciClearRootHubPortFeature (
1706 IN EFI_USB_HC_PROTOCOL *This,
1707 IN UINT8 PortNumber,
1708 IN EFI_USB_PORT_FEATURE PortFeature
1709 )
1710 {
1711 USB_OHCI_HC_DEV *Ohc;
1712 EFI_STATUS Status;
1713 UINT8 NumOfPorts;
1714 UINTN RetryTimes;
1715
1716
1717 OhciGetRootHubNumOfPorts (This, &NumOfPorts);
1718 if (PortNumber >= NumOfPorts) {
1719 return EFI_INVALID_PARAMETER;
1720 }
1721
1722 Ohc = USB_OHCI_HC_DEV_FROM_THIS (This);
1723
1724 Status = EFI_SUCCESS;
1725
1726 switch (PortFeature) {
1727 case EfiUsbPortEnable:
1728 Status = OhciSetRootHubPortStatus (Ohc, PortNumber, RH_CLEAR_PORT_ENABLE);
1729
1730 //
1731 // Verify the state
1732 //
1733 RetryTimes = 0;
1734 do {
1735 gBS->Stall (1000);
1736 RetryTimes++;
1737 } while (OhciReadRootHubPortStatus (Ohc, PortNumber, RH_PORT_ENABLE_STAT) == 1 &&
1738 RetryTimes < MAX_RETRY_TIMES);
1739
1740 if (RetryTimes >= MAX_RETRY_TIMES) {
1741 return EFI_DEVICE_ERROR;
1742 }
1743 break;
1744
1745 case EfiUsbPortSuspend:
1746 Status = OhciSetRootHubPortStatus (Ohc, PortNumber, RH_CLEAR_SUSPEND_STATUS);
1747
1748 //
1749 // Verify the state
1750 //
1751 RetryTimes = 0;
1752 do {
1753 gBS->Stall (1000);
1754 RetryTimes++;
1755 } while (OhciReadRootHubPortStatus (Ohc, PortNumber, RH_PORT_SUSPEND_STAT) == 1 &&
1756 RetryTimes < MAX_RETRY_TIMES);
1757
1758 if (RetryTimes >= MAX_RETRY_TIMES) {
1759 return EFI_DEVICE_ERROR;
1760 }
1761 break;
1762
1763 case EfiUsbPortReset:
1764 break;
1765
1766 case EfiUsbPortPower:
1767 Status = OhciSetRootHubPortStatus (Ohc, PortNumber, RH_CLEAR_PORT_POWER);
1768
1769 //
1770 // Verify the state
1771 //
1772 RetryTimes = 0;
1773 do {
1774 gBS->Stall (1000);
1775 RetryTimes++;
1776 } while (OhciReadRootHubPortStatus (Ohc, PortNumber, RH_PORT_POWER_STAT) == 1 &&
1777 RetryTimes < MAX_RETRY_TIMES);
1778
1779 if (RetryTimes >= MAX_RETRY_TIMES) {
1780 return EFI_DEVICE_ERROR;
1781 }
1782 break;
1783
1784 case EfiUsbPortConnectChange:
1785 Status = OhciSetRootHubPortStatus (Ohc, PortNumber, RH_CONNECT_STATUS_CHANGE);
1786
1787 //
1788 // Verify the state
1789 //
1790 RetryTimes = 0;
1791 do {
1792 gBS->Stall (1000);
1793 RetryTimes++;
1794 } while (OhciReadRootHubPortStatus (Ohc, PortNumber, RH_CONNECT_STATUS_CHANGE) == 1 &&
1795 RetryTimes < MAX_RETRY_TIMES);
1796
1797 if (RetryTimes >= MAX_RETRY_TIMES) {
1798 return EFI_DEVICE_ERROR;
1799 }
1800 break;
1801
1802 case EfiUsbPortResetChange:
1803 Status = OhciSetRootHubPortStatus (Ohc, PortNumber, RH_PORT_RESET_STAT_CHANGE);
1804
1805 //
1806 // Verify the state
1807 //
1808 RetryTimes = 0;
1809 do {
1810 gBS->Stall (1000);
1811 RetryTimes++;
1812 } while (OhciReadRootHubPortStatus (Ohc, PortNumber, RH_PORT_RESET_STAT_CHANGE) == 1 &&
1813 RetryTimes < MAX_RETRY_TIMES);
1814
1815 if (RetryTimes >= MAX_RETRY_TIMES) {
1816 return EFI_DEVICE_ERROR;
1817 }
1818 break;
1819
1820
1821 case EfiUsbPortEnableChange:
1822 Status = OhciSetRootHubPortStatus (Ohc, PortNumber, RH_PORT_ENABLE_STAT_CHANGE);
1823
1824 //
1825 // Verify the state
1826 //
1827 RetryTimes = 0;
1828 do {
1829 gBS->Stall (1000);
1830 RetryTimes++;
1831 } while (OhciReadRootHubPortStatus (Ohc, PortNumber, RH_PORT_ENABLE_STAT_CHANGE) == 1 &&
1832 RetryTimes < MAX_RETRY_TIMES);
1833
1834 if (RetryTimes >= MAX_RETRY_TIMES) {
1835 return EFI_DEVICE_ERROR;
1836 }
1837 break;
1838
1839 case EfiUsbPortSuspendChange:
1840 Status = OhciSetRootHubPortStatus (Ohc, PortNumber, RH_PORT_SUSPEND_STAT_CHANGE);
1841
1842 //
1843 // Verify the state
1844 //
1845 RetryTimes = 0;
1846 do {
1847 gBS->Stall (1000);
1848 RetryTimes++;
1849 } while (OhciReadRootHubPortStatus (Ohc, PortNumber, RH_PORT_SUSPEND_STAT_CHANGE) == 1 &&
1850 RetryTimes < MAX_RETRY_TIMES);
1851
1852 if (RetryTimes >= MAX_RETRY_TIMES) {
1853 return EFI_DEVICE_ERROR;
1854 }
1855 break;
1856
1857 case EfiUsbPortOverCurrentChange:
1858 Status = OhciSetRootHubPortStatus (Ohc, PortNumber, RH_OC_INDICATOR_CHANGE);
1859
1860 //
1861 // Verify the state
1862 //
1863 RetryTimes = 0;
1864 do {
1865 gBS->Stall (1000);
1866 RetryTimes++;
1867 } while (OhciReadRootHubPortStatus (Ohc, PortNumber, RH_OC_INDICATOR_CHANGE) == 1 &&
1868 RetryTimes < MAX_RETRY_TIMES);
1869
1870 if (RetryTimes >= MAX_RETRY_TIMES) {
1871 return EFI_DEVICE_ERROR;
1872 }
1873 break;
1874
1875 default:
1876 return EFI_INVALID_PARAMETER;
1877 }
1878
1879 return Status;
1880 }
1881
1882 EFI_DRIVER_BINDING_PROTOCOL gOhciDriverBinding = {
1883 OHCIDriverBindingSupported,
1884 OHCIDriverBindingStart,
1885 OHCIDriverBindingStop,
1886 0x10,
1887 NULL,
1888 NULL
1889 };
1890
1891
1892 /**
1893 Entry point for EFI drivers.
1894
1895 @param ImageHandle EFI_HANDLE.
1896 @param SystemTable EFI_SYSTEM_TABLE.
1897
1898 @retval EFI_SUCCESS Driver is successfully loaded.
1899 @return Others Failed.
1900
1901 **/
1902 EFI_STATUS
1903 EFIAPI
1904 OHCIDriverEntryPoint (
1905 IN EFI_HANDLE ImageHandle,
1906 IN EFI_SYSTEM_TABLE *SystemTable
1907 )
1908 {
1909 return EfiLibInstallDriverBindingComponentName2 (
1910 ImageHandle,
1911 SystemTable,
1912 &gOhciDriverBinding,
1913 ImageHandle,
1914 &gOhciComponentName,
1915 &gOhciComponentName2
1916 );
1917 }
1918
1919
1920 /**
1921 Test to see if this driver supports ControllerHandle. Any
1922 ControllerHandle that has UsbHcProtocol installed will be supported.
1923
1924 @param This Protocol instance pointer.
1925 @param Controller Handle of device to test.
1926 @param RemainingDevicePath Not used.
1927
1928 @return EFI_SUCCESS This driver supports this device.
1929 @return EFI_UNSUPPORTED This driver does not support this device.
1930
1931 **/
1932 EFI_STATUS
1933 EFIAPI
1934 OHCIDriverBindingSupported (
1935 IN EFI_DRIVER_BINDING_PROTOCOL *This,
1936 IN EFI_HANDLE Controller,
1937 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
1938 )
1939 {
1940 EFI_STATUS Status;
1941 EFI_PCI_IO_PROTOCOL *PciIo;
1942 USB_CLASSC UsbClassCReg;
1943 //
1944 // Test whether there is PCI IO Protocol attached on the controller handle.
1945 //
1946 Status = gBS->OpenProtocol (
1947 Controller,
1948 &gEfiPciIoProtocolGuid,
1949 (VOID **) &PciIo,
1950 This->DriverBindingHandle,
1951 Controller,
1952 EFI_OPEN_PROTOCOL_BY_DRIVER
1953 );
1954
1955 if (EFI_ERROR (Status)) {
1956 return EFI_UNSUPPORTED;
1957 }
1958
1959 Status = PciIo->Pci.Read (
1960 PciIo,
1961 EfiPciIoWidthUint8,
1962 PCI_CLASSCODE_OFFSET,
1963 sizeof (USB_CLASSC) / sizeof (UINT8),
1964 &UsbClassCReg
1965 );
1966
1967 if (EFI_ERROR (Status)) {
1968 Status = EFI_UNSUPPORTED;
1969 goto ON_EXIT;
1970 }
1971 //
1972 // Test whether the controller belongs to OHCI type
1973 //
1974 if ((UsbClassCReg.BaseCode != PCI_CLASS_SERIAL) ||
1975 (UsbClassCReg.SubClassCode != PCI_CLASS_SERIAL_USB) ||
1976 (UsbClassCReg.ProgInterface != PCI_IF_OHCI)
1977 ) {
1978
1979 Status = EFI_UNSUPPORTED;
1980 }
1981 ON_EXIT:
1982 gBS->CloseProtocol (
1983 Controller,
1984 &gEfiPciIoProtocolGuid,
1985 This->DriverBindingHandle,
1986 Controller
1987 );
1988
1989 return Status;
1990
1991 }
1992
1993 /**
1994
1995 Allocate and initialize the empty OHCI device.
1996
1997 @param PciIo The PCIIO to use.
1998 @param OriginalPciAttributes The original PCI attributes.
1999
2000 @return Allocated OHCI device If err, return NULL.
2001
2002 **/
2003
2004 USB_OHCI_HC_DEV *
2005 OhciAllocateDev (
2006 IN EFI_PCI_IO_PROTOCOL *PciIo,
2007 IN UINT64 OriginalPciAttributes
2008 )
2009 {
2010 USB_OHCI_HC_DEV *Ohc;
2011 EFI_STATUS Status;
2012 VOID *Buf;
2013 EFI_PHYSICAL_ADDRESS PhyAddr;
2014 VOID *Map;
2015 UINTN Pages;
2016 UINTN Bytes;
2017
2018 Ohc = AllocateZeroPool (sizeof (USB_OHCI_HC_DEV));
2019 if (Ohc == NULL) {
2020 return NULL;
2021 }
2022
2023 Ohc->Signature = USB_OHCI_HC_DEV_SIGNATURE;
2024 Ohc->PciIo = PciIo;
2025
2026 Ohc->UsbHc.Reset = OhciReset;
2027 Ohc->UsbHc.GetState = OhciGetState;
2028 Ohc->UsbHc.SetState = OhciSetState;
2029 Ohc->UsbHc.ControlTransfer = OhciControlTransfer;
2030 Ohc->UsbHc.BulkTransfer = OhciBulkTransfer;
2031 Ohc->UsbHc.AsyncInterruptTransfer = OhciAsyncInterruptTransfer;
2032 Ohc->UsbHc.SyncInterruptTransfer = OhciSyncInterruptTransfer;
2033 Ohc->UsbHc.IsochronousTransfer = OhciIsochronousTransfer;
2034 Ohc->UsbHc.AsyncIsochronousTransfer = OhciAsyncIsochronousTransfer;
2035 Ohc->UsbHc.GetRootHubPortNumber = OhciGetRootHubNumOfPorts;
2036 Ohc->UsbHc.GetRootHubPortStatus = OhciGetRootHubPortStatus;
2037 Ohc->UsbHc.SetRootHubPortFeature = OhciSetRootHubPortFeature;
2038 Ohc->UsbHc.ClearRootHubPortFeature = OhciClearRootHubPortFeature;
2039 Ohc->UsbHc.MajorRevision = 0x1;
2040 Ohc->UsbHc.MinorRevision = 0x1;
2041
2042 Ohc->OriginalPciAttributes = OriginalPciAttributes;
2043
2044 Ohc->HccaMemoryBlock = NULL;
2045 Ohc->HccaMemoryMapping = NULL;
2046 Ohc->HccaMemoryBuf = NULL;
2047 Ohc->HccaMemoryPages = 0;
2048 Ohc->InterruptContextList = NULL;
2049 Ohc->ControllerNameTable = NULL;
2050 Ohc->HouseKeeperTimer = NULL;
2051
2052 Ohc->MemPool = UsbHcInitMemPool(PciIo, TRUE, 0);
2053 if(Ohc->MemPool == NULL) {
2054 goto FREE_DEV_BUFFER;
2055 }
2056
2057 Bytes = 4096;
2058 Pages = EFI_SIZE_TO_PAGES (Bytes);
2059
2060 Status = PciIo->AllocateBuffer (
2061 PciIo,
2062 AllocateAnyPages,
2063 EfiBootServicesData,
2064 Pages,
2065 &Buf,
2066 0
2067 );
2068
2069 if (EFI_ERROR (Status)) {
2070 goto FREE_MEM_POOL;
2071 }
2072
2073 Status = PciIo->Map (
2074 PciIo,
2075 EfiPciIoOperationBusMasterCommonBuffer,
2076 Buf,
2077 &Bytes,
2078 &PhyAddr,
2079 &Map
2080 );
2081
2082 if (EFI_ERROR (Status) || (Bytes != 4096)) {
2083 goto FREE_MEM_PAGE;
2084 }
2085
2086 Ohc->HccaMemoryBlock = (HCCA_MEMORY_BLOCK *)(UINTN)PhyAddr;
2087 Ohc->HccaMemoryMapping = Map;
2088 Ohc->HccaMemoryBuf = (VOID *)(UINTN)Buf;
2089 Ohc->HccaMemoryPages = Pages;
2090
2091 return Ohc;
2092
2093 FREE_MEM_PAGE:
2094 PciIo->FreeBuffer (PciIo, Pages, Buf);
2095 FREE_MEM_POOL:
2096 UsbHcFreeMemPool (Ohc->MemPool);
2097 FREE_DEV_BUFFER:
2098 FreePool(Ohc);
2099
2100 return NULL;
2101 }
2102 /**
2103
2104 Free the OHCI device and release its associated resources.
2105
2106 @param Ohc The OHCI device to release.
2107
2108 **/
2109 VOID
2110 OhciFreeDev (
2111 IN USB_OHCI_HC_DEV *Ohc
2112 )
2113 {
2114 OhciFreeFixedIntMemory (Ohc);
2115
2116 if (Ohc->HouseKeeperTimer != NULL) {
2117 gBS->CloseEvent (Ohc->HouseKeeperTimer);
2118 }
2119
2120 if (Ohc->ExitBootServiceEvent != NULL) {
2121 gBS->CloseEvent (Ohc->ExitBootServiceEvent);
2122 }
2123
2124 if (Ohc->MemPool != NULL) {
2125 UsbHcFreeMemPool (Ohc->MemPool);
2126 }
2127
2128 if (Ohc->HccaMemoryMapping != NULL ) {
2129 Ohc->PciIo->FreeBuffer (Ohc->PciIo, Ohc->HccaMemoryPages, Ohc->HccaMemoryBuf);
2130 }
2131
2132 if (Ohc->ControllerNameTable != NULL) {
2133 FreeUnicodeStringTable (Ohc->ControllerNameTable);
2134 }
2135
2136 FreePool (Ohc);
2137 }
2138 /**
2139
2140 Uninstall all Ohci Interface.
2141
2142 @param Controller Controller handle.
2143 @param This Protocol instance pointer.
2144
2145 **/
2146 VOID
2147 OhciCleanDevUp (
2148 IN EFI_HANDLE Controller,
2149 IN EFI_USB_HC_PROTOCOL *This
2150 )
2151 {
2152 USB_OHCI_HC_DEV *Ohc;
2153
2154 //
2155 // Retrieve private context structure
2156 //
2157 Ohc = USB_OHCI_HC_DEV_FROM_THIS (This);
2158
2159 //
2160 // Uninstall the USB_HC and USB_HC2 protocol
2161 //
2162 gBS->UninstallProtocolInterface (
2163 Controller,
2164 &gEfiUsbHcProtocolGuid,
2165 &Ohc->UsbHc
2166 );
2167
2168 //
2169 // Cancel the timer event
2170 //
2171 gBS->SetTimer (Ohc->HouseKeeperTimer, TimerCancel, 0);
2172
2173 //
2174 // Stop the host controller
2175 //
2176 OhciSetHcControl (Ohc, PERIODIC_ENABLE | CONTROL_ENABLE | ISOCHRONOUS_ENABLE | BULK_ENABLE, 0);
2177 This->Reset (This, EFI_USB_HC_RESET_GLOBAL);
2178 This->SetState (This, EfiUsbHcStateHalt);
2179
2180 //
2181 // Free resources
2182 //
2183 OhciFreeDynamicIntMemory (Ohc);
2184
2185 //
2186 // Restore original PCI attributes
2187 //
2188 Ohc->PciIo->Attributes (
2189 Ohc->PciIo,
2190 EfiPciIoAttributeOperationSet,
2191 Ohc->OriginalPciAttributes,
2192 NULL
2193 );
2194
2195 //
2196 // Free the private context structure
2197 //
2198 OhciFreeDev (Ohc);
2199 }
2200
2201 /**
2202
2203 One notified function to stop the Host Controller when gBS->ExitBootServices() called.
2204
2205 @param Event Pointer to this event
2206 @param Context Event hanlder private data
2207 **/
2208 VOID
2209 EFIAPI
2210 OhcExitBootService (
2211 EFI_EVENT Event,
2212 VOID *Context
2213 )
2214 {
2215 USB_OHCI_HC_DEV *Ohc;
2216 EFI_USB_HC_PROTOCOL *UsbHc;
2217 Ohc = (USB_OHCI_HC_DEV *) Context;
2218
2219 UsbHc = &Ohc->UsbHc;
2220 //
2221 // Stop the Host Controller
2222 //
2223 //OhciStopHc (Ohc, OHC_GENERIC_TIMEOUT);
2224 OhciSetHcControl (Ohc, PERIODIC_ENABLE | CONTROL_ENABLE | ISOCHRONOUS_ENABLE | BULK_ENABLE, 0);
2225 UsbHc->Reset (UsbHc, EFI_USB_HC_RESET_GLOBAL);
2226 UsbHc->SetState (UsbHc, EfiUsbHcStateHalt);
2227
2228 return;
2229 }
2230
2231
2232 /**
2233 Starting the Usb OHCI Driver.
2234
2235 @param This Protocol instance pointer.
2236 @param Controller Handle of device to test.
2237 @param RemainingDevicePath Not used.
2238
2239 @retval EFI_SUCCESS This driver supports this device.
2240 @retval EFI_UNSUPPORTED This driver does not support this device.
2241 @retval EFI_DEVICE_ERROR This driver cannot be started due to device Error.
2242 EFI_OUT_OF_RESOURCES- Failed due to resource shortage.
2243
2244 **/
2245 EFI_STATUS
2246 EFIAPI
2247 OHCIDriverBindingStart (
2248 IN EFI_DRIVER_BINDING_PROTOCOL *This,
2249 IN EFI_HANDLE Controller,
2250 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
2251 )
2252 {
2253 EFI_STATUS Status;
2254 EFI_PCI_IO_PROTOCOL *PciIo;
2255 USB_OHCI_HC_DEV *Ohc;
2256 UINT64 Supports;
2257 UINT64 OriginalPciAttributes;
2258 BOOLEAN PciAttributesSaved;
2259
2260 //
2261 // Open PCIIO, then enable the HC device and turn off emulation
2262 //
2263 Ohc = NULL;
2264 Status = gBS->OpenProtocol (
2265 Controller,
2266 &gEfiPciIoProtocolGuid,
2267 (VOID **) &PciIo,
2268 This->DriverBindingHandle,
2269 Controller,
2270 EFI_OPEN_PROTOCOL_BY_DRIVER
2271 );
2272
2273 if (EFI_ERROR (Status)) {
2274 return Status;
2275 }
2276
2277 PciAttributesSaved = FALSE;
2278 //
2279 // Save original PCI attributes
2280 //
2281 Status = PciIo->Attributes (
2282 PciIo,
2283 EfiPciIoAttributeOperationGet,
2284 0,
2285 &OriginalPciAttributes
2286 );
2287
2288 if (EFI_ERROR (Status)) {
2289 goto CLOSE_PCIIO;
2290 }
2291 PciAttributesSaved = TRUE;
2292
2293 //
2294 // Robustnesss improvement such as for UoL
2295 // Default is not required.
2296 //
2297 //if (FeaturePcdGet (PcdTurnOffUsbLegacySupport)) {
2298 // OhciTurnOffUsbEmulation (PciIo);
2299 //}
2300
2301 Status = PciIo->Attributes (
2302 PciIo,
2303 EfiPciIoAttributeOperationSupported,
2304 0,
2305 &Supports
2306 );
2307 if (!EFI_ERROR (Status)) {
2308 Supports &= EFI_PCI_DEVICE_ENABLE;
2309 Status = PciIo->Attributes (
2310 PciIo,
2311 EfiPciIoAttributeOperationEnable,
2312 Supports,
2313 NULL
2314 );
2315 }
2316
2317 if (EFI_ERROR (Status)) {
2318 goto CLOSE_PCIIO;
2319 }
2320 //
2321 //Allocate memory for OHC private data structure
2322 //
2323 Ohc = OhciAllocateDev(PciIo, OriginalPciAttributes);
2324 if (Ohc == NULL){
2325 Status = EFI_OUT_OF_RESOURCES;
2326 goto CLOSE_PCIIO;
2327 }
2328
2329 //Status = OhciInitializeInterruptList ( Uhc );
2330 //if (EFI_ERROR (Status)) {
2331 // goto FREE_OHC;
2332 //}
2333
2334 //
2335 // Set 0.01 s timer
2336 //
2337 Status = gBS->CreateEvent (
2338 EVT_TIMER | EVT_NOTIFY_SIGNAL,
2339 TPL_NOTIFY,
2340 OhciHouseKeeper,
2341 Ohc,
2342 &Ohc->HouseKeeperTimer
2343 );
2344 if (EFI_ERROR (Status)) {
2345 goto FREE_OHC;
2346 }
2347
2348 Status = gBS->SetTimer (Ohc->HouseKeeperTimer, TimerPeriodic, 10 * 1000 * 10);
2349 if (EFI_ERROR (Status)) {
2350 goto FREE_OHC;
2351 }
2352
2353 //
2354 //Install Host Controller Protocol
2355 //
2356 Status = gBS->InstallProtocolInterface (
2357 &Controller,
2358 &gEfiUsbHcProtocolGuid,
2359 EFI_NATIVE_INTERFACE,
2360 &Ohc->UsbHc
2361 );
2362 if (EFI_ERROR (Status)) {
2363 DEBUG ((EFI_D_INFO, "Install protocol error"));
2364 goto FREE_OHC;
2365 }
2366 //
2367 // Create event to stop the HC when exit boot service.
2368 //
2369 Status = gBS->CreateEventEx (
2370 EVT_NOTIFY_SIGNAL,
2371 TPL_NOTIFY,
2372 OhcExitBootService,
2373 Ohc,
2374 &gEfiEventExitBootServicesGuid,
2375 &Ohc->ExitBootServiceEvent
2376 );
2377 if (EFI_ERROR (Status)) {
2378 DEBUG ((EFI_D_INFO, "Create exit boot event error"));
2379 goto UNINSTALL_USBHC;
2380 }
2381 AddUnicodeString2 (
2382 "eng",
2383 gOhciComponentName.SupportedLanguages,
2384 &Ohc->ControllerNameTable,
2385 L"Usb Universal Host Controller",
2386 TRUE
2387 );
2388 AddUnicodeString2 (
2389 "en",
2390 gOhciComponentName2.SupportedLanguages,
2391 &Ohc->ControllerNameTable,
2392 L"Usb Universal Host Controller",
2393 FALSE
2394 );
2395
2396 return EFI_SUCCESS;
2397
2398 UNINSTALL_USBHC:
2399 gBS->UninstallMultipleProtocolInterfaces (
2400 Controller,
2401 &gEfiUsbHcProtocolGuid,
2402 &Ohc->UsbHc,
2403 NULL
2404 );
2405
2406 FREE_OHC:
2407 OhciFreeDev (Ohc);
2408
2409 CLOSE_PCIIO:
2410 if (PciAttributesSaved) {
2411 //
2412 // Restore original PCI attributes
2413 //
2414 PciIo->Attributes (
2415 PciIo,
2416 EfiPciIoAttributeOperationSet,
2417 OriginalPciAttributes,
2418 NULL
2419 );
2420 }
2421
2422 gBS->CloseProtocol (
2423 Controller,
2424 &gEfiPciIoProtocolGuid,
2425 This->DriverBindingHandle,
2426 Controller
2427 );
2428 return Status;
2429 }
2430
2431 /**
2432 Stop this driver on ControllerHandle. Support stoping any child handles
2433 created by this driver.
2434
2435 @param This Protocol instance pointer.
2436 @param Controller Handle of device to stop driver on.
2437 @param NumberOfChildren Number of Children in the ChildHandleBuffer.
2438 @param ChildHandleBuffer List of handles for the children we need to stop.
2439
2440 @return EFI_SUCCESS
2441 @return others
2442
2443 **/
2444 EFI_STATUS
2445 EFIAPI
2446 OHCIDriverBindingStop (
2447 IN EFI_DRIVER_BINDING_PROTOCOL *This,
2448 IN EFI_HANDLE Controller,
2449 IN UINTN NumberOfChildren,
2450 IN EFI_HANDLE *ChildHandleBuffer
2451 )
2452 {
2453 EFI_STATUS Status;
2454 EFI_USB_HC_PROTOCOL *UsbHc;
2455
2456 Status = gBS->OpenProtocol (
2457 Controller,
2458 &gEfiUsbHcProtocolGuid,
2459 (VOID **)&UsbHc,
2460 This->DriverBindingHandle,
2461 Controller,
2462 EFI_OPEN_PROTOCOL_GET_PROTOCOL
2463 );
2464 if (EFI_ERROR (Status)) {
2465 return Status;
2466 }
2467
2468 OhciCleanDevUp(Controller, UsbHc);
2469
2470 gBS->CloseProtocol (
2471 Controller,
2472 &gEfiPciIoProtocolGuid,
2473 This->DriverBindingHandle,
2474 Controller
2475 );
2476 return EFI_SUCCESS;
2477 }
2478
2479
EFI Development Kit II mirror for PVE