1 /** @file 2 OHCI transfer scheduling routines. 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 21 Add an item of interrupt context 22 23 @param Ohc UHC private data 24 @param NewEntry New entry to add 25 26 @retval EFI_SUCCESS Item successfully added 27 28 **/ 29 EFI_STATUS 30 OhciAddInterruptContextEntry ( 31 IN USB_OHCI_HC_DEV *Ohc, 32 IN INTERRUPT_CONTEXT_ENTRY *NewEntry 33 ) 34 { 35 INTERRUPT_CONTEXT_ENTRY *Entry; 36 EFI_TPL OriginalTPL; 37 38 OriginalTPL = gBS->RaiseTPL (TPL_NOTIFY); 39 40 if (Ohc->InterruptContextList == NULL) { 41 Ohc->InterruptContextList = NewEntry; 42 } else { 43 Entry = Ohc->InterruptContextList; 44 while (Entry->NextEntry != NULL) { 45 Entry = Entry->NextEntry; 46 } 47 Entry->NextEntry = NewEntry; 48 } 49 50 gBS->RestoreTPL (OriginalTPL); 51 52 return EFI_SUCCESS; 53 } 54 55 56 /** 57 58 Free a interrupt context entry 59 60 @param Ohc UHC private data 61 @param Entry Pointer to an interrupt context entry 62 63 @retval EFI_SUCCESS Entry freed 64 @retval EFI_INVALID_PARAMETER Entry is NULL 65 66 **/ 67 EFI_STATUS 68 OhciFreeInterruptContextEntry ( 69 IN USB_OHCI_HC_DEV *Ohc, 70 IN INTERRUPT_CONTEXT_ENTRY *Entry 71 ) 72 { 73 TD_DESCRIPTOR *Td; 74 if (Entry == NULL) { 75 return EFI_INVALID_PARAMETER; 76 } 77 if (Entry->UCBufferMapping != NULL) { 78 Ohc->PciIo->Unmap(Ohc->PciIo, Entry->UCBufferMapping); 79 } 80 if (Entry->UCBuffer != NULL) { 81 FreePool(Entry->UCBuffer); 82 } 83 while (Entry->DataTd) { 84 Td = Entry->DataTd; 85 Entry->DataTd = (TD_DESCRIPTOR *)(UINTN)(Entry->DataTd->NextTDPointer); 86 UsbHcFreeMem(Ohc->MemPool, Td, sizeof(TD_DESCRIPTOR)); 87 } 88 FreePool(Entry); 89 return EFI_SUCCESS; 90 } 91 92 93 /** 94 95 Free entries match the device address and endpoint address 96 97 @Param Ohc UHC private date 98 @Param DeviceAddress Item to free must match this device address 99 @Param EndPointAddress Item to free must match this end point address 100 @Param DataToggle DataToggle for output 101 102 @retval EFI_SUCCESS Items match the requirement removed 103 104 **/ 105 EFI_STATUS 106 OhciFreeInterruptContext( 107 IN USB_OHCI_HC_DEV *Ohc, 108 IN UINT8 DeviceAddress, 109 IN UINT8 EndPointAddress, 110 OUT UINT8 *DataToggle 111 ) 112 { 113 INTERRUPT_CONTEXT_ENTRY *Entry; 114 INTERRUPT_CONTEXT_ENTRY *TempEntry; 115 EFI_TPL OriginalTPL; 116 117 118 OriginalTPL = gBS->RaiseTPL (TPL_NOTIFY); 119 120 while (Ohc->InterruptContextList != NULL && 121 Ohc->InterruptContextList->DeviceAddress == DeviceAddress && 122 Ohc->InterruptContextList->EndPointAddress == EndPointAddress) { 123 TempEntry = Ohc->InterruptContextList; 124 Ohc->InterruptContextList = Ohc->InterruptContextList->NextEntry; 125 if (DataToggle != NULL) { 126 *DataToggle = (UINT8) (TempEntry->DataTd->Word0.DataToggle & 0x1); 127 } 128 OhciFreeInterruptContextEntry (Ohc, TempEntry); 129 } 130 131 Entry = Ohc->InterruptContextList; 132 if (Entry == NULL) { 133 gBS->RestoreTPL (OriginalTPL); 134 return EFI_SUCCESS; 135 } 136 while (Entry->NextEntry != NULL) { 137 if (Entry->NextEntry->DeviceAddress == DeviceAddress && 138 Entry->NextEntry->EndPointAddress == EndPointAddress) { 139 TempEntry = Entry->NextEntry; 140 Entry->NextEntry = Entry->NextEntry->NextEntry; 141 if (DataToggle != NULL) { 142 *DataToggle = (UINT8) (TempEntry->DataTd->Word0.DataToggle & 0x1); 143 } 144 OhciFreeInterruptContextEntry (Ohc, TempEntry); 145 } else { 146 Entry = Entry->NextEntry; 147 } 148 } 149 150 gBS->RestoreTPL (OriginalTPL); 151 152 return EFI_SUCCESS; 153 } 154 155 156 /** 157 158 Convert Error code from OHCI format to EFI format 159 160 @Param ErrorCode ErrorCode in OHCI format 161 162 @retval ErrorCode in EFI format 163 164 **/ 165 UINT32 166 ConvertErrorCode ( 167 IN UINT32 ErrorCode 168 ) 169 { 170 UINT32 TransferResult; 171 172 switch (ErrorCode) { 173 case TD_NO_ERROR: 174 TransferResult = EFI_USB_NOERROR; 175 break; 176 177 case TD_TOBE_PROCESSED: 178 case TD_TOBE_PROCESSED_2: 179 TransferResult = EFI_USB_ERR_NOTEXECUTE; 180 break; 181 182 case TD_DEVICE_STALL: 183 TransferResult = EFI_USB_ERR_STALL; 184 break; 185 186 case TD_BUFFER_OVERRUN: 187 case TD_BUFFER_UNDERRUN: 188 TransferResult = EFI_USB_ERR_BUFFER; 189 break; 190 191 case TD_CRC_ERROR: 192 TransferResult = EFI_USB_ERR_CRC; 193 break; 194 195 case TD_NO_RESPONSE: 196 TransferResult = EFI_USB_ERR_TIMEOUT; 197 break; 198 199 case TD_BITSTUFFING_ERROR: 200 TransferResult = EFI_USB_ERR_BITSTUFF; 201 break; 202 203 default: 204 TransferResult = EFI_USB_ERR_SYSTEM; 205 } 206 207 return TransferResult; 208 } 209 210 211 /** 212 213 Check TDs Results 214 215 @Param Ohc UHC private data 216 @Param Td TD_DESCRIPTOR 217 @Param Result Result to return 218 219 @retval TRUE means OK 220 @retval FLASE means Error or Short packet 221 222 **/ 223 BOOLEAN 224 OhciCheckTDsResults ( 225 IN USB_OHCI_HC_DEV *Ohc, 226 IN TD_DESCRIPTOR *Td, 227 OUT UINT32 *Result 228 ) 229 { 230 UINT32 TdCompletionCode; 231 232 *Result = EFI_USB_NOERROR; 233 234 while (Td) { 235 TdCompletionCode = Td->Word0.ConditionCode; 236 237 *Result |= ConvertErrorCode(TdCompletionCode); 238 // 239 // if any error encountered, stop processing the left TDs. 240 // 241 if (*Result) { 242 return FALSE; 243 } 244 245 Td = (TD_DESCRIPTOR *)(UINTN)(Td->NextTDPointer); 246 } 247 return TRUE; 248 249 } 250 251 252 /** 253 254 Check the task status on an ED 255 256 @Param Ed Pointer to the ED task that TD hooked on 257 @Param HeadTd TD header for current transaction 258 259 @retval Task Status Code 260 261 **/ 262 263 UINT32 264 CheckEDStatus ( 265 IN ED_DESCRIPTOR *Ed, 266 IN TD_DESCRIPTOR *HeadTd, 267 OUT OHCI_ED_RESULT *EdResult 268 ) 269 { 270 while(HeadTd != NULL) { 271 if (HeadTd->NextTDPointer == 0) { 272 return TD_NO_ERROR; 273 } 274 if (HeadTd->Word0.ConditionCode != 0) { 275 return HeadTd->Word0.ConditionCode; 276 } 277 EdResult->NextToggle = ((UINT8)(HeadTd->Word0.DataToggle) & BIT0) ^ BIT0; 278 HeadTd = (TD_DESCRIPTOR *)(UINTN)(HeadTd->NextTDPointer); 279 } 280 if (OhciGetEDField (Ed, ED_TDHEAD_PTR) != OhciGetEDField (Ed, ED_TDTAIL_PTR)) { 281 return TD_TOBE_PROCESSED; 282 } 283 return TD_NO_ERROR; 284 } 285 286 /** 287 288 Check the task status 289 290 @Param Ohc UHC private data 291 @Param ListType Pipe type 292 @Param Ed Pointer to the ED task hooked on 293 @Param HeadTd Head of TD corresponding to the task 294 @Param ErrorCode return the ErrorCode 295 296 @retval EFI_SUCCESS Task done 297 @retval EFI_NOT_READY Task on processing 298 @retval EFI_DEVICE_ERROR Some error occured 299 300 **/ 301 EFI_STATUS 302 CheckIfDone ( 303 IN USB_OHCI_HC_DEV *Ohc, 304 IN DESCRIPTOR_LIST_TYPE ListType, 305 IN ED_DESCRIPTOR *Ed, 306 IN TD_DESCRIPTOR *HeadTd, 307 OUT OHCI_ED_RESULT *EdResult 308 ) 309 { 310 EdResult->ErrorCode = TD_TOBE_PROCESSED; 311 312 switch (ListType) { 313 case CONTROL_LIST: 314 if (OhciGetHcCommandStatus (Ohc, CONTROL_LIST_FILLED) != 0) { 315 return EFI_NOT_READY; 316 } 317 break; 318 case BULK_LIST: 319 if (OhciGetHcCommandStatus (Ohc, BULK_LIST_FILLED) != 0) { 320 return EFI_NOT_READY; 321 } 322 break; 323 default: 324 break; 325 } 326 327 EdResult->ErrorCode = CheckEDStatus (Ed, HeadTd, EdResult); 328 329 if (EdResult->ErrorCode == TD_NO_ERROR) { 330 return EFI_SUCCESS; 331 } else if (EdResult->ErrorCode == TD_TOBE_PROCESSED) { 332 return EFI_NOT_READY; 333 } else { 334 return EFI_DEVICE_ERROR; 335 } 336 } 337 338 339 /** 340 341 Convert TD condition code to Efi Status 342 343 @Param ConditionCode Condition code to convert 344 345 @retval EFI_SUCCESS No error occured 346 @retval EFI_NOT_READY TD still on processing 347 @retval EFI_DEVICE_ERROR Error occured in processing TD 348 349 **/ 350 351 EFI_STATUS 352 OhciTDConditionCodeToStatus ( 353 IN UINT32 ConditionCode 354 ) 355 { 356 if (ConditionCode == TD_NO_ERROR) { 357 return EFI_SUCCESS; 358 } 359 360 if (ConditionCode == TD_TOBE_PROCESSED) { 361 return EFI_NOT_READY; 362 } 363 364 return EFI_DEVICE_ERROR; 365 } 366 367 /** 368 369 Invoke callbacks hooked on done TDs 370 371 @Param Entry Interrupt transfer transaction information data structure 372 @Param Context Ohc private data 373 374 **/ 375 376 VOID 377 OhciInvokeInterruptCallBack( 378 IN INTERRUPT_CONTEXT_ENTRY *Entry, 379 IN UINT32 Result 380 ) 381 { 382 //Generally speaking, Keyboard driver should not 383 //check the Keyboard buffer if an error happens, it will be robust 384 //if we NULLed the buffer once error happens 385 if (Result) { 386 Entry->CallBackFunction ( 387 NULL, 388 0, 389 Entry->Context, 390 Result 391 ); 392 }else{ 393 Entry->CallBackFunction ( 394 (VOID *)(UINTN)(Entry->DataTd->DataBuffer), 395 Entry->DataTd->ActualSendLength, 396 Entry->Context, 397 Result 398 ); 399 } 400 } 401 402 403 /** 404 405 Timer to submit periodic interrupt transfer, and invoke callbacks hooked on done TDs 406 407 @param Event Event handle 408 @param Context Device private data 409 410 **/ 411 412 VOID 413 EFIAPI 414 OhciHouseKeeper ( 415 IN EFI_EVENT Event, 416 IN VOID *Context 417 ) 418 { 419 420 USB_OHCI_HC_DEV *Ohc; 421 INTERRUPT_CONTEXT_ENTRY *Entry; 422 INTERRUPT_CONTEXT_ENTRY *PreEntry; 423 ED_DESCRIPTOR *Ed; 424 TD_DESCRIPTOR *DataTd; 425 TD_DESCRIPTOR *HeadTd; 426 427 UINT8 Toggle; 428 EFI_TPL OriginalTPL; 429 UINT32 Result; 430 431 Ohc = (USB_OHCI_HC_DEV *) Context; 432 OriginalTPL = gBS->RaiseTPL(TPL_NOTIFY); 433 434 Entry = Ohc->InterruptContextList; 435 PreEntry = NULL; 436 437 while(Entry != NULL) { 438 439 OhciCheckTDsResults(Ohc, Entry->DataTd, &Result ); 440 if (((Result & EFI_USB_ERR_STALL) == EFI_USB_ERR_STALL) || 441 ((Result & EFI_USB_ERR_NOTEXECUTE) == EFI_USB_ERR_NOTEXECUTE)) { 442 PreEntry = Entry; 443 Entry = Entry->NextEntry; 444 continue; 445 } 446 447 if (Entry->CallBackFunction != NULL) { 448 OhciInvokeInterruptCallBack (Entry, Result); 449 if (Ohc->InterruptContextList == NULL) { 450 gBS->RestoreTPL (OriginalTPL); 451 return; 452 } 453 } 454 if (Entry->IsPeriodic) { 455 456 Ed = Entry->Ed; 457 HeadTd = Entry->DataTd; 458 DataTd = HeadTd; 459 Toggle = 0; 460 if (Result == EFI_USB_NOERROR) { 461 // 462 // Update toggle if there is no error, and re-submit the interrupt Ed&Tds 463 // 464 if ((Ed != NULL) && (DataTd != NULL)) { 465 Ed->Word0.Skip = 1; 466 } 467 // 468 // From hcir1_0a.pdf 4.2.2 469 // ToggleCarry:This bit is the data toggle carry bit, 470 // Whenever a TD is retired, this bit is written to 471 // contain the last data toggle value(LSb of data Toggel 472 // file) from the retired TD. 473 // This field is not used for Isochronous Endpoints 474 // 475 if (Ed == NULL) { 476 return; 477 } 478 Toggle = (UINT8) OhciGetEDField (Ed, ED_DTTOGGLE); 479 while(DataTd != NULL) { 480 if (DataTd->NextTDPointer == 0) { 481 DataTd->Word0.DataToggle = 0; 482 break; 483 } else { 484 OhciSetTDField (DataTd, TD_DT_TOGGLE, Toggle); 485 } 486 DataTd = (TD_DESCRIPTOR *)(UINTN)(DataTd->NextTDPointer); 487 Toggle ^= 1; 488 } 489 // 490 // HC will only update DataToggle, ErrorCount, ConditionCode 491 // CurrentBufferPointer & NextTD, so we only need to update 492 // them once we want to active them again 493 // 494 DataTd = HeadTd; 495 while (DataTd != NULL) { 496 if (DataTd->NextTDPointer == 0) { 497 OhciSetTDField (DataTd, TD_ERROR_CNT | TD_COND_CODE | TD_CURR_BUFFER_PTR | TD_NEXT_PTR, 0); 498 break; 499 } 500 OhciSetTDField (DataTd, TD_ERROR_CNT, 0); 501 OhciSetTDField (DataTd, TD_COND_CODE, TD_TOBE_PROCESSED); 502 DataTd->NextTD = DataTd->NextTDPointer; 503 DataTd->CurrBufferPointer = DataTd->DataBuffer; 504 DataTd = (TD_DESCRIPTOR *)(UINTN)(DataTd->NextTDPointer); 505 } 506 // 507 // Active current Ed,Td 508 // 509 // HC will only update Halted, ToggleCarry & TDQueueHeadPointer, 510 // So we only need to update them once we want to active them again. 511 // 512 if ((Ed != NULL) && (DataTd != NULL)) { 513 Ed->Word2.TdHeadPointer = (UINT32)((UINTN)HeadTd>>4); 514 OhciSetEDField (Ed, ED_HALTED | ED_DTTOGGLE, 0); 515 Ed->Word0.Skip = 0; 516 } 517 } 518 } else { 519 if (PreEntry == NULL) { 520 Ohc->InterruptContextList = Entry->NextEntry; 521 } else { 522 PreEntry = Entry; 523 PreEntry->NextEntry = Entry->NextEntry; 524 } 525 OhciFreeInterruptContextEntry (Ohc, PreEntry); 526 gBS->RestoreTPL (OriginalTPL); 527 return; 528 } 529 PreEntry = Entry; 530 Entry = Entry->NextEntry; 531 } 532 gBS->RestoreTPL (OriginalTPL); 533 } 534 535
