1 /** @file 2 3 Copyright (c) 2014, Intel Corporation. All rights reserved.<BR> 4 This program and the accompanying materials 5 are licensed and made available under the terms and conditions of the BSD License 6 which accompanies this distribution. The full text of the license may be found at 7 http://opensource.org/licenses/bsd-license.php. 8 9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 11 12 **/ 13 14 #include "UfsBlockIoPei.h" 15 16 /** 17 Wait for the value of the specified system memory set to the test value. 18 19 @param Address The system memory address to test. 20 @param MaskValue The mask value of memory. 21 @param TestValue The test value of memory. 22 @param Timeout The time out value for wait memory set, uses 100ns as a unit. 23 24 @retval EFI_TIMEOUT The system memory setting is time out. 25 @retval EFI_SUCCESS The system memory is correct set. 26 27 **/ 28 EFI_STATUS 29 EFIAPI 30 UfsWaitMemSet ( 31 IN UINTN Address, 32 IN UINT32 MaskValue, 33 IN UINT32 TestValue, 34 IN UINT64 Timeout 35 ) 36 { 37 UINT32 Value; 38 UINT64 Delay; 39 BOOLEAN InfiniteWait; 40 41 if (Timeout == 0) { 42 InfiniteWait = TRUE; 43 } else { 44 InfiniteWait = FALSE; 45 } 46 47 Delay = DivU64x32 (Timeout, 10) + 1; 48 49 do { 50 // 51 // Access PCI MMIO space to see if the value is the tested one. 52 // 53 Value = MmioRead32 (Address) & MaskValue; 54 55 if (Value == TestValue) { 56 return EFI_SUCCESS; 57 } 58 59 // 60 // Stall for 1 microseconds. 61 // 62 MicroSecondDelay (1); 63 64 Delay--; 65 66 } while (InfiniteWait || (Delay > 0)); 67 68 return EFI_TIMEOUT; 69 } 70 71 /** 72 Dump UIC command execution result for debugging. 73 74 @param[in] UicOpcode The executed UIC opcode. 75 @param[in] Result The result to be parsed. 76 77 **/ 78 VOID 79 DumpUicCmdExecResult ( 80 IN UINT8 UicOpcode, 81 IN UINT8 Result 82 ) 83 { 84 if (UicOpcode <= UfsUicDmePeerSet) { 85 switch (Result) { 86 case 0x00: 87 break; 88 case 0x01: 89 DEBUG ((EFI_D_VERBOSE, "UIC configuration command fails - INVALID_MIB_ATTRIBUTE\n")); 90 break; 91 case 0x02: 92 DEBUG ((EFI_D_VERBOSE, "UIC configuration command fails - INVALID_MIB_ATTRIBUTE_VALUE\n")); 93 break; 94 case 0x03: 95 DEBUG ((EFI_D_VERBOSE, "UIC configuration command fails - READ_ONLY_MIB_ATTRIBUTE\n")); 96 break; 97 case 0x04: 98 DEBUG ((EFI_D_VERBOSE, "UIC configuration command fails - WRITE_ONLY_MIB_ATTRIBUTE\n")); 99 break; 100 case 0x05: 101 DEBUG ((EFI_D_VERBOSE, "UIC configuration command fails - BAD_INDEX\n")); 102 break; 103 case 0x06: 104 DEBUG ((EFI_D_VERBOSE, "UIC configuration command fails - LOCKED_MIB_ATTRIBUTE\n")); 105 break; 106 case 0x07: 107 DEBUG ((EFI_D_VERBOSE, "UIC configuration command fails - BAD_TEST_FEATURE_INDEX\n")); 108 break; 109 case 0x08: 110 DEBUG ((EFI_D_VERBOSE, "UIC configuration command fails - PEER_COMMUNICATION_FAILURE\n")); 111 break; 112 case 0x09: 113 DEBUG ((EFI_D_VERBOSE, "UIC configuration command fails - BUSY\n")); 114 break; 115 case 0x0A: 116 DEBUG ((EFI_D_VERBOSE, "UIC configuration command fails - DME_FAILURE\n")); 117 break; 118 default : 119 ASSERT (FALSE); 120 break; 121 } 122 } else { 123 switch (Result) { 124 case 0x00: 125 break; 126 case 0x01: 127 DEBUG ((EFI_D_VERBOSE, "UIC control command fails - FAILURE\n")); 128 break; 129 default : 130 ASSERT (FALSE); 131 break; 132 } 133 } 134 } 135 136 /** 137 Dump QUERY RESPONSE UPIU result for debugging. 138 139 @param[in] Result The result to be parsed. 140 141 **/ 142 VOID 143 DumpQueryResponseResult ( 144 IN UINT8 Result 145 ) 146 { 147 switch (Result) { 148 case 0xF6: 149 DEBUG ((EFI_D_VERBOSE, "Query Response with Parameter Not Readable\n")); 150 break; 151 case 0xF7: 152 DEBUG ((EFI_D_VERBOSE, "Query Response with Parameter Not Writeable\n")); 153 break; 154 case 0xF8: 155 DEBUG ((EFI_D_VERBOSE, "Query Response with Parameter Already Written\n")); 156 break; 157 case 0xF9: 158 DEBUG ((EFI_D_VERBOSE, "Query Response with Invalid Length\n")); 159 break; 160 case 0xFA: 161 DEBUG ((EFI_D_VERBOSE, "Query Response with Invalid Value\n")); 162 break; 163 case 0xFB: 164 DEBUG ((EFI_D_VERBOSE, "Query Response with Invalid Selector\n")); 165 break; 166 case 0xFC: 167 DEBUG ((EFI_D_VERBOSE, "Query Response with Invalid Index\n")); 168 break; 169 case 0xFD: 170 DEBUG ((EFI_D_VERBOSE, "Query Response with Invalid Idn\n")); 171 break; 172 case 0xFE: 173 DEBUG ((EFI_D_VERBOSE, "Query Response with Invalid Opcode\n")); 174 break; 175 case 0xFF: 176 DEBUG ((EFI_D_VERBOSE, "Query Response with General Failure\n")); 177 break; 178 default : 179 ASSERT (FALSE); 180 break; 181 } 182 } 183 184 /** 185 Swap little endian to big endian. 186 187 @param[in, out] Buffer The data buffer. In input, it contains little endian data. 188 In output, it will become big endian. 189 @param[in] BufferSize The length of converted data. 190 191 **/ 192 VOID 193 SwapLittleEndianToBigEndian ( 194 IN OUT UINT8 *Buffer, 195 IN UINT32 BufferSize 196 ) 197 { 198 UINT32 Index; 199 UINT8 Temp; 200 UINT32 SwapCount; 201 202 SwapCount = BufferSize / 2; 203 for (Index = 0; Index < SwapCount; Index++) { 204 Temp = Buffer[Index]; 205 Buffer[Index] = Buffer[BufferSize - 1 - Index]; 206 Buffer[BufferSize - 1 - Index] = Temp; 207 } 208 } 209 210 /** 211 Fill TSF field of QUERY REQUEST UPIU. 212 213 @param[in, out] TsfBase The base address of TSF field of QUERY REQUEST UPIU. 214 @param[in] Opcode The opcode of request. 215 @param[in] DescId The descriptor ID of request. 216 @param[in] Index The index of request. 217 @param[in] Selector The selector of request. 218 @param[in] Length The length of transferred data. The maximum is 4. 219 @param[in] Value The value of transferred data. 220 221 **/ 222 VOID 223 UfsFillTsfOfQueryReqUpiu ( 224 IN OUT UTP_UPIU_TSF *TsfBase, 225 IN UINT8 Opcode, 226 IN UINT8 DescId OPTIONAL, 227 IN UINT8 Index OPTIONAL, 228 IN UINT8 Selector OPTIONAL, 229 IN UINT16 Length OPTIONAL, 230 IN UINT32 Value OPTIONAL 231 ) 232 { 233 ASSERT (TsfBase != NULL); 234 ASSERT (Opcode <= UtpQueryFuncOpcodeTogFlag); 235 236 TsfBase->Opcode = Opcode; 237 if (Opcode != UtpQueryFuncOpcodeNop) { 238 TsfBase->DescId = DescId; 239 TsfBase->Index = Index; 240 TsfBase->Selector = Selector; 241 242 if ((Opcode == UtpQueryFuncOpcodeRdDesc) || (Opcode == UtpQueryFuncOpcodeWrDesc)) { 243 SwapLittleEndianToBigEndian ((UINT8*)&Length, sizeof (Length)); 244 TsfBase->Length = Length; 245 } 246 247 if (Opcode == UtpQueryFuncOpcodeWrAttr) { 248 SwapLittleEndianToBigEndian ((UINT8*)&Value, sizeof (Value)); 249 TsfBase->Value = Value; 250 } 251 } 252 } 253 254 /** 255 Initialize COMMAND UPIU. 256 257 @param[in, out] Command The base address of COMMAND UPIU. 258 @param[in] Lun The Lun on which the SCSI command is executed. 259 @param[in] TaskTag The task tag of request. 260 @param[in] Cdb The cdb buffer containing SCSI command. 261 @param[in] CdbLength The cdb length. 262 @param[in] DataDirection The direction of data transfer. 263 @param[in] ExpDataTranLen The expected transfer data length. 264 265 @retval EFI_SUCCESS The initialization succeed. 266 267 **/ 268 EFI_STATUS 269 UfsInitCommandUpiu ( 270 IN OUT UTP_COMMAND_UPIU *Command, 271 IN UINT8 Lun, 272 IN UINT8 TaskTag, 273 IN UINT8 *Cdb, 274 IN UINT8 CdbLength, 275 IN UFS_DATA_DIRECTION DataDirection, 276 IN UINT32 ExpDataTranLen 277 ) 278 { 279 UINT8 Flags; 280 281 ASSERT ((Command != NULL) && (Cdb != NULL)); 282 283 // 284 // Task attribute is hard-coded to Ordered. 285 // 286 if (DataDirection == UfsDataIn) { 287 Flags = BIT0 | BIT6; 288 } else if (DataDirection == UfsDataOut) { 289 Flags = BIT0 | BIT5; 290 } else { 291 Flags = BIT0; 292 } 293 294 // 295 // Fill UTP COMMAND UPIU associated fields. 296 // 297 Command->TransCode = 0x01; 298 Command->Flags = Flags; 299 Command->Lun = Lun; 300 Command->TaskTag = TaskTag; 301 Command->CmdSet = 0x00; 302 SwapLittleEndianToBigEndian ((UINT8*)&ExpDataTranLen, sizeof (ExpDataTranLen)); 303 Command->ExpDataTranLen = ExpDataTranLen; 304 305 CopyMem (Command->Cdb, Cdb, CdbLength); 306 307 return EFI_SUCCESS; 308 } 309 310 /** 311 Initialize UTP PRDT for data transfer. 312 313 @param[in] Prdt The base address of PRDT. 314 @param[in] Buffer The buffer to be read or written. 315 @param[in] BufferSize The data size to be read or written. 316 317 @retval EFI_SUCCESS The initialization succeed. 318 319 **/ 320 EFI_STATUS 321 UfsInitUtpPrdt ( 322 IN UTP_TR_PRD *Prdt, 323 IN VOID *Buffer, 324 IN UINT32 BufferSize 325 ) 326 { 327 UINT32 PrdtIndex; 328 UINT32 RemainingLen; 329 UINT8 *Remaining; 330 UINTN PrdtNumber; 331 332 if (BufferSize == 0) { 333 return EFI_SUCCESS; 334 } 335 336 ASSERT (((UINTN)Buffer & (BIT0 | BIT1)) == 0); 337 338 RemainingLen = BufferSize; 339 Remaining = Buffer; 340 PrdtNumber = (UINTN)DivU64x32 ((UINT64)BufferSize + UFS_MAX_DATA_LEN_PER_PRD - 1, UFS_MAX_DATA_LEN_PER_PRD); 341 342 for (PrdtIndex = 0; PrdtIndex < PrdtNumber; PrdtIndex++) { 343 if (RemainingLen < UFS_MAX_DATA_LEN_PER_PRD) { 344 Prdt[PrdtIndex].DbCount = (UINT32)RemainingLen - 1; 345 } else { 346 Prdt[PrdtIndex].DbCount = UFS_MAX_DATA_LEN_PER_PRD - 1; 347 } 348 349 Prdt[PrdtIndex].DbAddr = (UINT32)RShiftU64 ((UINT64)(UINTN)Remaining, 2); 350 Prdt[PrdtIndex].DbAddrU = (UINT32)RShiftU64 ((UINT64)(UINTN)Remaining, 32); 351 RemainingLen -= UFS_MAX_DATA_LEN_PER_PRD; 352 Remaining += UFS_MAX_DATA_LEN_PER_PRD; 353 } 354 355 return EFI_SUCCESS; 356 } 357 358 /** 359 Initialize QUERY REQUEST UPIU. 360 361 @param[in, out] QueryReq The base address of QUERY REQUEST UPIU. 362 @param[in] TaskTag The task tag of request. 363 @param[in] Opcode The opcode of request. 364 @param[in] DescId The descriptor ID of request. 365 @param[in] Index The index of request. 366 @param[in] Selector The selector of request. 367 @param[in] DataSize The data size to be read or written. 368 @param[in] Data The buffer to be read or written. 369 370 @retval EFI_SUCCESS The initialization succeed. 371 372 **/ 373 EFI_STATUS 374 UfsInitQueryRequestUpiu ( 375 IN OUT UTP_QUERY_REQ_UPIU *QueryReq, 376 IN UINT8 TaskTag, 377 IN UINT8 Opcode, 378 IN UINT8 DescId, 379 IN UINT8 Index, 380 IN UINT8 Selector, 381 IN UINTN DataSize OPTIONAL, 382 IN UINT8 *Data OPTIONAL 383 ) 384 { 385 ASSERT (QueryReq != NULL); 386 387 QueryReq->TransCode = 0x16; 388 QueryReq->TaskTag = TaskTag; 389 if ((Opcode == UtpQueryFuncOpcodeRdDesc) || (Opcode == UtpQueryFuncOpcodeRdFlag) || (Opcode == UtpQueryFuncOpcodeRdAttr)) { 390 QueryReq->QueryFunc = QUERY_FUNC_STD_READ_REQ; 391 } else { 392 QueryReq->QueryFunc = QUERY_FUNC_STD_WRITE_REQ; 393 } 394 395 if (Opcode == UtpQueryFuncOpcodeWrAttr) { 396 UfsFillTsfOfQueryReqUpiu (&QueryReq->Tsf, Opcode, DescId, Index, Selector, 0, *(UINT32*)Data); 397 } else if ((Opcode == UtpQueryFuncOpcodeRdDesc) || (Opcode == UtpQueryFuncOpcodeWrDesc)) { 398 UfsFillTsfOfQueryReqUpiu (&QueryReq->Tsf, Opcode, DescId, Index, Selector, (UINT16)DataSize, 0); 399 } else { 400 UfsFillTsfOfQueryReqUpiu (&QueryReq->Tsf, Opcode, DescId, Index, Selector, 0, 0); 401 } 402 403 if (Opcode == UtpQueryFuncOpcodeWrDesc) { 404 CopyMem (QueryReq + 1, Data, DataSize); 405 } 406 407 return EFI_SUCCESS; 408 } 409 410 /** 411 Allocate COMMAND/RESPONSE UPIU for filling UTP TRD's command descriptor field. 412 413 @param[in] Private The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure. 414 @param[in] Lun The Lun on which the SCSI command is executed. 415 @param[in] Packet The pointer to the UFS_SCSI_REQUEST_PACKET data structure. 416 @param[in] Trd The pointer to the UTP Transfer Request Descriptor. 417 418 @retval EFI_SUCCESS The creation succeed. 419 @retval EFI_DEVICE_ERROR The creation failed. 420 @retval EFI_OUT_OF_RESOURCES The memory resource is insufficient. 421 422 **/ 423 EFI_STATUS 424 UfsCreateScsiCommandDesc ( 425 IN UFS_PEIM_HC_PRIVATE_DATA *Private, 426 IN UINT8 Lun, 427 IN UFS_SCSI_REQUEST_PACKET *Packet, 428 IN UTP_TRD *Trd 429 ) 430 { 431 UINT8 *CommandDesc; 432 UINTN TotalLen; 433 UINTN PrdtNumber; 434 VOID *Buffer; 435 UINT32 Length; 436 UTP_COMMAND_UPIU *CommandUpiu; 437 UTP_TR_PRD *PrdtBase; 438 UFS_DATA_DIRECTION DataDirection; 439 440 ASSERT ((Private != NULL) && (Packet != NULL) && (Trd != NULL)); 441 442 if (Packet->DataDirection == UfsDataIn) { 443 Buffer = Packet->InDataBuffer; 444 Length = Packet->InTransferLength; 445 DataDirection = UfsDataIn; 446 } else { 447 Buffer = Packet->OutDataBuffer; 448 Length = Packet->OutTransferLength; 449 DataDirection = UfsDataOut; 450 } 451 452 if (Length == 0) { 453 DataDirection = UfsNoData; 454 } 455 456 PrdtNumber = (UINTN)DivU64x32 ((UINT64)Length + UFS_MAX_DATA_LEN_PER_PRD - 1, UFS_MAX_DATA_LEN_PER_PRD); 457 458 TotalLen = ROUNDUP8 (sizeof (UTP_COMMAND_UPIU)) + ROUNDUP8 (sizeof (UTP_RESPONSE_UPIU)) + PrdtNumber * sizeof (UTP_TR_PRD); 459 CommandDesc = UfsPeimAllocateMem (Private->Pool, TotalLen); 460 if (CommandDesc == NULL) { 461 return EFI_OUT_OF_RESOURCES; 462 } 463 464 CommandUpiu = (UTP_COMMAND_UPIU*)CommandDesc; 465 PrdtBase = (UTP_TR_PRD*)(CommandDesc + ROUNDUP8 (sizeof (UTP_COMMAND_UPIU)) + ROUNDUP8 (sizeof (UTP_RESPONSE_UPIU))); 466 467 UfsInitCommandUpiu (CommandUpiu, Lun, Private->TaskTag++, Packet->Cdb, Packet->CdbLength, DataDirection, Length); 468 UfsInitUtpPrdt (PrdtBase, Buffer, Length); 469 470 // 471 // Fill UTP_TRD associated fields 472 // NOTE: Some UFS host controllers request the Response UPIU and the Physical Region Description Table 473 // *MUST* be located at a 64-bit aligned boundary. 474 // 475 Trd->Int = UFS_INTERRUPT_COMMAND; 476 Trd->Dd = DataDirection; 477 Trd->Ct = UFS_STORAGE_COMMAND_TYPE; 478 Trd->UcdBa = (UINT32)RShiftU64 ((UINT64)(UINTN)CommandUpiu, 7); 479 Trd->UcdBaU = (UINT32)RShiftU64 ((UINT64)(UINTN)CommandUpiu, 32); 480 Trd->RuL = (UINT16)DivU64x32 ((UINT64)ROUNDUP8 (sizeof (UTP_RESPONSE_UPIU)), sizeof (UINT32)); 481 Trd->RuO = (UINT16)DivU64x32 ((UINT64)ROUNDUP8 (sizeof (UTP_COMMAND_UPIU)), sizeof (UINT32)); 482 Trd->PrdtL = (UINT16)PrdtNumber; 483 Trd->PrdtO = (UINT16)DivU64x32 ((UINT64)(ROUNDUP8 (sizeof (UTP_COMMAND_UPIU)) + ROUNDUP8 (sizeof (UTP_RESPONSE_UPIU))), sizeof (UINT32)); 484 return EFI_SUCCESS; 485 } 486 487 /** 488 Allocate QUERY REQUEST/QUERY RESPONSE UPIU for filling UTP TRD's command descriptor field. 489 490 @param[in] Private The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure. 491 @param[in] Packet The pointer to the UFS_DEVICE_MANAGEMENT_REQUEST_PACKET data structure. 492 @param[in] Trd The pointer to the UTP Transfer Request Descriptor. 493 494 @retval EFI_SUCCESS The creation succeed. 495 @retval EFI_DEVICE_ERROR The creation failed. 496 @retval EFI_OUT_OF_RESOURCES The memory resource is insufficient. 497 @retval EFI_INVALID_PARAMETER The parameter passed in is invalid. 498 499 **/ 500 EFI_STATUS 501 UfsCreateDMCommandDesc ( 502 IN UFS_PEIM_HC_PRIVATE_DATA *Private, 503 IN UFS_DEVICE_MANAGEMENT_REQUEST_PACKET *Packet, 504 IN UTP_TRD *Trd 505 ) 506 { 507 UINT8 *CommandDesc; 508 UINTN TotalLen; 509 UTP_QUERY_REQ_UPIU *QueryReqUpiu; 510 UINT8 Opcode; 511 UINT32 DataSize; 512 UINT8 *Data; 513 UINT8 DataDirection; 514 515 ASSERT ((Private != NULL) && (Packet != NULL) && (Trd != NULL)); 516 517 Opcode = Packet->Opcode; 518 if ((Opcode > UtpQueryFuncOpcodeTogFlag) || (Opcode == UtpQueryFuncOpcodeNop)) { 519 return EFI_INVALID_PARAMETER; 520 } 521 522 DataDirection = Packet->DataDirection; 523 if (DataDirection == UfsDataIn) { 524 DataSize = Packet->InTransferLength; 525 Data = Packet->InDataBuffer; 526 } else if (DataDirection == UfsDataOut) { 527 DataSize = Packet->OutTransferLength; 528 Data = Packet->OutDataBuffer; 529 } else { 530 DataSize = 0; 531 Data = NULL; 532 } 533 534 if (((Opcode != UtpQueryFuncOpcodeSetFlag) && (Opcode != UtpQueryFuncOpcodeClrFlag) && (Opcode != UtpQueryFuncOpcodeTogFlag)) 535 && ((DataSize == 0) || (Data == NULL))) { 536 return EFI_INVALID_PARAMETER; 537 } 538 539 if (((Opcode == UtpQueryFuncOpcodeSetFlag) || (Opcode == UtpQueryFuncOpcodeClrFlag) || (Opcode == UtpQueryFuncOpcodeTogFlag)) 540 && ((DataSize != 0) || (Data != NULL))) { 541 return EFI_INVALID_PARAMETER; 542 } 543 544 if ((Opcode == UtpQueryFuncOpcodeWrAttr) && (DataSize != sizeof (UINT32))) { 545 return EFI_INVALID_PARAMETER; 546 } 547 548 if ((Opcode == UtpQueryFuncOpcodeWrDesc) || (Opcode == UtpQueryFuncOpcodeRdDesc)) { 549 TotalLen = ROUNDUP8 (sizeof (UTP_QUERY_REQ_UPIU)) + ROUNDUP8 (sizeof (UTP_QUERY_RESP_UPIU)) + ROUNDUP8 (DataSize); 550 } else { 551 TotalLen = ROUNDUP8 (sizeof (UTP_QUERY_REQ_UPIU)) + ROUNDUP8 (sizeof (UTP_QUERY_RESP_UPIU)); 552 } 553 554 CommandDesc = UfsPeimAllocateMem (Private->Pool, TotalLen); 555 if (CommandDesc == NULL) { 556 return EFI_OUT_OF_RESOURCES; 557 } 558 559 // 560 // Initialize UTP QUERY REQUEST UPIU 561 // 562 QueryReqUpiu = (UTP_QUERY_REQ_UPIU*)CommandDesc; 563 UfsInitQueryRequestUpiu ( 564 QueryReqUpiu, 565 Private->TaskTag++, 566 Opcode, 567 Packet->DescId, 568 Packet->Index, 569 Packet->Selector, 570 DataSize, 571 Data 572 ); 573 574 // 575 // Fill UTP_TRD associated fields 576 // NOTE: Some UFS host controllers request the Query Response UPIU *MUST* be located at a 64-bit aligned boundary. 577 // 578 Trd->Int = UFS_INTERRUPT_COMMAND; 579 Trd->Dd = DataDirection; 580 Trd->Ct = UFS_STORAGE_COMMAND_TYPE; 581 Trd->Ocs = 0x0F; 582 Trd->UcdBa = (UINT32)RShiftU64 ((UINT64)(UINTN)QueryReqUpiu, 7); 583 Trd->UcdBaU = (UINT32)RShiftU64 ((UINT64)(UINTN)QueryReqUpiu, 32); 584 if (Opcode == UtpQueryFuncOpcodeWrDesc) { 585 Trd->RuL = (UINT16)DivU64x32 ((UINT64)ROUNDUP8 (sizeof (UTP_QUERY_RESP_UPIU)), sizeof (UINT32)); 586 Trd->RuO = (UINT16)DivU64x32 ((UINT64)(ROUNDUP8 (sizeof (UTP_QUERY_REQ_UPIU)) + ROUNDUP8 (DataSize)), sizeof (UINT32)); 587 } else { 588 Trd->RuL = (UINT16)DivU64x32 ((UINT64)(ROUNDUP8 (sizeof (UTP_QUERY_RESP_UPIU)) + ROUNDUP8 (DataSize)), sizeof (UINT32)); 589 Trd->RuO = (UINT16)DivU64x32 ((UINT64)ROUNDUP8 (sizeof (UTP_QUERY_REQ_UPIU)), sizeof (UINT32)); 590 } 591 592 return EFI_SUCCESS; 593 } 594 595 /** 596 Allocate NOP IN and NOP OUT UPIU for filling UTP TRD's command descriptor field. 597 598 @param[in] Private The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure. 599 @param[in] Trd The pointer to the UTP Transfer Request Descriptor. 600 601 @retval EFI_SUCCESS The creation succeed. 602 @retval EFI_DEVICE_ERROR The creation failed. 603 @retval EFI_OUT_OF_RESOURCES The memory resource is insufficient. 604 605 **/ 606 EFI_STATUS 607 UfsCreateNopCommandDesc ( 608 IN UFS_PEIM_HC_PRIVATE_DATA *Private, 609 IN UTP_TRD *Trd 610 ) 611 { 612 UINT8 *CommandDesc; 613 UINTN TotalLen; 614 UTP_NOP_OUT_UPIU *NopOutUpiu; 615 616 ASSERT ((Private != NULL) && (Trd != NULL)); 617 618 TotalLen = ROUNDUP8 (sizeof (UTP_NOP_OUT_UPIU)) + ROUNDUP8 (sizeof (UTP_NOP_IN_UPIU)); 619 CommandDesc = UfsPeimAllocateMem (Private->Pool, TotalLen); 620 if (CommandDesc == NULL) { 621 return EFI_OUT_OF_RESOURCES; 622 } 623 624 NopOutUpiu = (UTP_NOP_OUT_UPIU*)CommandDesc; 625 626 NopOutUpiu->TaskTag = Private->TaskTag++; 627 628 // 629 // Fill UTP_TRD associated fields 630 // NOTE: Some UFS host controllers request the Nop Out UPIU *MUST* be located at a 64-bit aligned boundary. 631 // 632 Trd->Int = UFS_INTERRUPT_COMMAND; 633 Trd->Dd = 0x00; 634 Trd->Ct = UFS_STORAGE_COMMAND_TYPE; 635 Trd->UcdBa = (UINT32)RShiftU64 ((UINT64)(UINTN)NopOutUpiu, 7); 636 Trd->UcdBaU = (UINT32)RShiftU64 ((UINT64)(UINTN)NopOutUpiu, 32); 637 Trd->RuL = (UINT16)DivU64x32 ((UINT64)ROUNDUP8 (sizeof (UTP_NOP_IN_UPIU)), sizeof (UINT32)); 638 Trd->RuO = (UINT16)DivU64x32 ((UINT64)ROUNDUP8 (sizeof (UTP_NOP_OUT_UPIU)), sizeof (UINT32)); 639 640 return EFI_SUCCESS; 641 } 642 643 /** 644 Find out available slot in transfer list of a UFS device. 645 646 @param[in] Private The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure. 647 @param[out] Slot The available slot. 648 649 @retval EFI_SUCCESS The available slot was found successfully. 650 651 **/ 652 EFI_STATUS 653 UfsFindAvailableSlotInTrl ( 654 IN UFS_PEIM_HC_PRIVATE_DATA *Private, 655 OUT UINT8 *Slot 656 ) 657 { 658 ASSERT ((Private != NULL) && (Slot != NULL)); 659 660 // 661 // The simplest algo to always use slot 0. 662 // TODO: enhance it to support async transfer with multiple slot. 663 // 664 *Slot = 0; 665 666 return EFI_SUCCESS; 667 } 668 669 /** 670 Find out available slot in task management transfer list of a UFS device. 671 672 @param[in] Private The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure. 673 @param[out] Slot The available slot. 674 675 @retval EFI_SUCCESS The available slot was found successfully. 676 677 **/ 678 EFI_STATUS 679 UfsFindAvailableSlotInTmrl ( 680 IN UFS_PEIM_HC_PRIVATE_DATA *Private, 681 OUT UINT8 *Slot 682 ) 683 { 684 ASSERT ((Private != NULL) && (Slot != NULL)); 685 686 // 687 // The simplest algo to always use slot 0. 688 // TODO: enhance it to support async transfer with multiple slot. 689 // 690 *Slot = 0; 691 692 return EFI_SUCCESS; 693 } 694 695 /** 696 Start specified slot in transfer list of a UFS device. 697 698 @param[in] Private The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure. 699 @param[in] Slot The slot to be started. 700 701 **/ 702 VOID 703 UfsStartExecCmd ( 704 IN UFS_PEIM_HC_PRIVATE_DATA *Private, 705 IN UINT8 Slot 706 ) 707 { 708 UINTN UfsHcBase; 709 UINTN Address; 710 UINT32 Data; 711 712 UfsHcBase = Private->UfsHcBase; 713 714 Address = UfsHcBase + UFS_HC_UTRLRSR_OFFSET; 715 Data = MmioRead32 (Address); 716 if ((Data & UFS_HC_UTRLRSR) != UFS_HC_UTRLRSR) { 717 MmioWrite32 (Address, UFS_HC_UTRLRSR); 718 } 719 720 Address = UfsHcBase + UFS_HC_UTRLDBR_OFFSET; 721 MmioWrite32 (Address, BIT0 << Slot); 722 } 723 724 /** 725 Stop specified slot in transfer list of a UFS device. 726 727 @param[in] Private The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure. 728 @param[in] Slot The slot to be stop. 729 730 **/ 731 VOID 732 UfsStopExecCmd ( 733 IN UFS_PEIM_HC_PRIVATE_DATA *Private, 734 IN UINT8 Slot 735 ) 736 { 737 UINTN UfsHcBase; 738 UINTN Address; 739 UINT32 Data; 740 741 UfsHcBase = Private->UfsHcBase; 742 743 Address = UfsHcBase + UFS_HC_UTRLDBR_OFFSET; 744 Data = MmioRead32 (Address); 745 if ((Data & (BIT0 << Slot)) != 0) { 746 Address = UfsHcBase + UFS_HC_UTRLCLR_OFFSET; 747 Data = MmioRead32 (Address); 748 MmioWrite32 (Address, (Data & ~(BIT0 << Slot))); 749 } 750 } 751 752 /** 753 Read or write specified device descriptor of a UFS device. 754 755 @param[in] Private The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure. 756 @param[in] Read The boolean variable to show r/w direction. 757 @param[in] DescId The ID of device descriptor. 758 @param[in] Index The Index of device descriptor. 759 @param[in] Selector The Selector of device descriptor. 760 @param[in, out] Descriptor The buffer of device descriptor to be read or written. 761 @param[in] DescSize The size of device descriptor buffer. 762 763 @retval EFI_SUCCESS The device descriptor was read/written successfully. 764 @retval EFI_DEVICE_ERROR A device error occurred while attempting to r/w the device descriptor. 765 @retval EFI_TIMEOUT A timeout occurred while waiting for the completion of r/w the device descriptor. 766 767 **/ 768 EFI_STATUS 769 UfsRwDeviceDesc ( 770 IN UFS_PEIM_HC_PRIVATE_DATA *Private, 771 IN BOOLEAN Read, 772 IN UINT8 DescId, 773 IN UINT8 Index, 774 IN UINT8 Selector, 775 IN OUT VOID *Descriptor, 776 IN UINT32 DescSize 777 ) 778 { 779 EFI_STATUS Status; 780 UFS_DEVICE_MANAGEMENT_REQUEST_PACKET Packet; 781 UINT8 Slot; 782 UTP_TRD *Trd; 783 UINTN Address; 784 UTP_QUERY_RESP_UPIU *QueryResp; 785 UINT8 *CmdDescBase; 786 UINT32 CmdDescSize; 787 UINT16 ReturnDataSize; 788 789 ZeroMem (&Packet, sizeof (UFS_DEVICE_MANAGEMENT_REQUEST_PACKET)); 790 791 if (Read) { 792 Packet.DataDirection = UfsDataIn; 793 Packet.InDataBuffer = Descriptor; 794 Packet.InTransferLength = DescSize; 795 Packet.Opcode = UtpQueryFuncOpcodeRdDesc; 796 } else { 797 Packet.DataDirection = UfsDataOut; 798 Packet.OutDataBuffer = Descriptor; 799 Packet.OutTransferLength = DescSize; 800 Packet.Opcode = UtpQueryFuncOpcodeWrDesc; 801 } 802 Packet.DescId = DescId; 803 Packet.Index = Index; 804 Packet.Selector = Selector; 805 Packet.Timeout = UFS_TIMEOUT; 806 807 // 808 // Find out which slot of transfer request list is available. 809 // 810 Status = UfsFindAvailableSlotInTrl (Private, &Slot); 811 if (EFI_ERROR (Status)) { 812 return Status; 813 } 814 815 Trd = ((UTP_TRD*)Private->UtpTrlBase) + Slot; 816 // 817 // Fill transfer request descriptor to this slot. 818 // 819 Status = UfsCreateDMCommandDesc (Private, &Packet, Trd); 820 if (EFI_ERROR (Status)) { 821 return Status; 822 } 823 824 // 825 // Check the transfer request result. 826 // 827 CmdDescBase = (UINT8 *)(UINTN)(LShiftU64 ((UINT64)Trd->UcdBaU, 32) | LShiftU64 ((UINT64)Trd->UcdBa, 7)); 828 QueryResp = (UTP_QUERY_RESP_UPIU*)(CmdDescBase + Trd->RuO * sizeof (UINT32)); 829 CmdDescSize = Trd->RuO * sizeof (UINT32) + Trd->RuL * sizeof (UINT32); 830 831 // 832 // Start to execute the transfer request. 833 // 834 UfsStartExecCmd (Private, Slot); 835 836 // 837 // Wait for the completion of the transfer request. 838 // 839 Address = Private->UfsHcBase + UFS_HC_UTRLDBR_OFFSET; 840 Status = UfsWaitMemSet (Address, BIT0, 0, Packet.Timeout); 841 if (EFI_ERROR (Status)) { 842 goto Exit; 843 } 844 845 if (QueryResp->QueryResp != 0) { 846 DumpQueryResponseResult (QueryResp->QueryResp); 847 Status = EFI_DEVICE_ERROR; 848 goto Exit; 849 } 850 851 if (Trd->Ocs == 0) { 852 ReturnDataSize = QueryResp->Tsf.Length; 853 SwapLittleEndianToBigEndian ((UINT8*)&ReturnDataSize, sizeof (UINT16)); 854 855 if (Read) { 856 CopyMem (Packet.InDataBuffer, (QueryResp + 1), ReturnDataSize); 857 Packet.InTransferLength = ReturnDataSize; 858 } else { 859 Packet.OutTransferLength = ReturnDataSize; 860 } 861 } else { 862 Status = EFI_DEVICE_ERROR; 863 } 864 865 Exit: 866 UfsStopExecCmd (Private, Slot); 867 UfsPeimFreeMem (Private->Pool, CmdDescBase, CmdDescSize); 868 869 return Status; 870 } 871 872 /** 873 Read or write specified attribute of a UFS device. 874 875 @param[in] Private The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure. 876 @param[in] Read The boolean variable to show r/w direction. 877 @param[in] AttrId The ID of Attribute. 878 @param[in] Index The Index of Attribute. 879 @param[in] Selector The Selector of Attribute. 880 @param[in, out] Attributes The value of Attribute to be read or written. 881 882 @retval EFI_SUCCESS The Attribute was read/written successfully. 883 @retval EFI_DEVICE_ERROR A device error occurred while attempting to r/w the Attribute. 884 @retval EFI_TIMEOUT A timeout occurred while waiting for the completion of r/w the Attribute. 885 886 **/ 887 EFI_STATUS 888 UfsRwAttributes ( 889 IN UFS_PEIM_HC_PRIVATE_DATA *Private, 890 IN BOOLEAN Read, 891 IN UINT8 AttrId, 892 IN UINT8 Index, 893 IN UINT8 Selector, 894 IN OUT UINT32 *Attributes 895 ) 896 { 897 EFI_STATUS Status; 898 UFS_DEVICE_MANAGEMENT_REQUEST_PACKET Packet; 899 UINT8 Slot; 900 UTP_TRD *Trd; 901 UINTN Address; 902 UTP_QUERY_RESP_UPIU *QueryResp; 903 UINT8 *CmdDescBase; 904 UINT32 CmdDescSize; 905 UINT32 ReturnData; 906 907 ZeroMem (&Packet, sizeof (UFS_DEVICE_MANAGEMENT_REQUEST_PACKET)); 908 909 if (Read) { 910 Packet.DataDirection = UfsDataIn; 911 Packet.Opcode = UtpQueryFuncOpcodeRdAttr; 912 } else { 913 Packet.DataDirection = UfsDataOut; 914 Packet.Opcode = UtpQueryFuncOpcodeWrAttr; 915 } 916 Packet.DescId = AttrId; 917 Packet.Index = Index; 918 Packet.Selector = Selector; 919 Packet.Timeout = UFS_TIMEOUT; 920 921 // 922 // Find out which slot of transfer request list is available. 923 // 924 Status = UfsFindAvailableSlotInTrl (Private, &Slot); 925 if (EFI_ERROR (Status)) { 926 return Status; 927 } 928 929 Trd = ((UTP_TRD*)Private->UtpTrlBase) + Slot; 930 // 931 // Fill transfer request descriptor to this slot. 932 // 933 Status = UfsCreateDMCommandDesc (Private, &Packet, Trd); 934 if (EFI_ERROR (Status)) { 935 return Status; 936 } 937 938 // 939 // Check the transfer request result. 940 // 941 CmdDescBase = (UINT8 *)(UINTN)(LShiftU64 ((UINT64)Trd->UcdBaU, 32) | LShiftU64 ((UINT64)Trd->UcdBa, 7)); 942 QueryResp = (UTP_QUERY_RESP_UPIU*)(CmdDescBase + Trd->RuO * sizeof (UINT32)); 943 CmdDescSize = Trd->RuO * sizeof (UINT32) + Trd->RuL * sizeof (UINT32); 944 945 // 946 // Start to execute the transfer request. 947 // 948 UfsStartExecCmd (Private, Slot); 949 950 // 951 // Wait for the completion of the transfer request. 952 // 953 Address = Private->UfsHcBase + UFS_HC_UTRLDBR_OFFSET; 954 Status = UfsWaitMemSet (Address, BIT0, 0, Packet.Timeout); 955 if (EFI_ERROR (Status)) { 956 goto Exit; 957 } 958 959 if (QueryResp->QueryResp != 0) { 960 DumpQueryResponseResult (QueryResp->QueryResp); 961 Status = EFI_DEVICE_ERROR; 962 goto Exit; 963 } 964 965 if (Trd->Ocs == 0) { 966 ReturnData = QueryResp->Tsf.Value; 967 SwapLittleEndianToBigEndian ((UINT8*)&ReturnData, sizeof (UINT32)); 968 *Attributes = ReturnData; 969 } else { 970 Status = EFI_DEVICE_ERROR; 971 } 972 973 Exit: 974 UfsStopExecCmd (Private, Slot); 975 UfsPeimFreeMem (Private->Pool, CmdDescBase, CmdDescSize); 976 977 return Status; 978 } 979 980 /** 981 Read or write specified flag of a UFS device. 982 983 @param[in] Private The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure. 984 @param[in] Read The boolean variable to show r/w direction. 985 @param[in] FlagId The ID of flag to be read or written. 986 @param[in, out] Value The value to set or clear flag. 987 988 @retval EFI_SUCCESS The flag was read/written successfully. 989 @retval EFI_DEVICE_ERROR A device error occurred while attempting to r/w the flag. 990 @retval EFI_TIMEOUT A timeout occurred while waiting for the completion of r/w the flag. 991 992 **/ 993 EFI_STATUS 994 UfsRwFlags ( 995 IN UFS_PEIM_HC_PRIVATE_DATA *Private, 996 IN BOOLEAN Read, 997 IN UINT8 FlagId, 998 IN OUT UINT8 *Value 999 ) 1000 { 1001 EFI_STATUS Status; 1002 UFS_DEVICE_MANAGEMENT_REQUEST_PACKET Packet; 1003 UINT8 Slot; 1004 UTP_TRD *Trd; 1005 UINTN Address; 1006 UTP_QUERY_RESP_UPIU *QueryResp; 1007 UINT8 *CmdDescBase; 1008 UINT32 CmdDescSize; 1009 1010 if (Value == NULL) { 1011 return EFI_INVALID_PARAMETER; 1012 } 1013 1014 ZeroMem (&Packet, sizeof (UFS_DEVICE_MANAGEMENT_REQUEST_PACKET)); 1015 1016 if (Read) { 1017 ASSERT (Value != NULL); 1018 Packet.DataDirection = UfsDataIn; 1019 Packet.Opcode = UtpQueryFuncOpcodeRdFlag; 1020 } else { 1021 Packet.DataDirection = UfsDataOut; 1022 if (*Value == 1) { 1023 Packet.Opcode = UtpQueryFuncOpcodeSetFlag; 1024 } else if (*Value == 0) { 1025 Packet.Opcode = UtpQueryFuncOpcodeClrFlag; 1026 } else { 1027 return EFI_INVALID_PARAMETER; 1028 } 1029 } 1030 Packet.DescId = FlagId; 1031 Packet.Index = 0; 1032 Packet.Selector = 0; 1033 Packet.Timeout = UFS_TIMEOUT; 1034 1035 // 1036 // Find out which slot of transfer request list is available. 1037 // 1038 Status = UfsFindAvailableSlotInTrl (Private, &Slot); 1039 if (EFI_ERROR (Status)) { 1040 return Status; 1041 } 1042 1043 // 1044 // Fill transfer request descriptor to this slot. 1045 // 1046 Trd = ((UTP_TRD*)Private->UtpTrlBase) + Slot; 1047 Status = UfsCreateDMCommandDesc (Private, &Packet, Trd); 1048 if (EFI_ERROR (Status)) { 1049 return Status; 1050 } 1051 1052 // 1053 // Check the transfer request result. 1054 // 1055 CmdDescBase = (UINT8 *)(UINTN)(LShiftU64 ((UINT64)Trd->UcdBaU, 32) | LShiftU64 ((UINT64)Trd->UcdBa, 7)); 1056 QueryResp = (UTP_QUERY_RESP_UPIU*)(CmdDescBase + Trd->RuO * sizeof (UINT32)); 1057 CmdDescSize = Trd->RuO * sizeof (UINT32) + Trd->RuL * sizeof (UINT32); 1058 1059 // 1060 // Start to execute the transfer request. 1061 // 1062 UfsStartExecCmd (Private, Slot); 1063 1064 // 1065 // Wait for the completion of the transfer request. 1066 // 1067 Address = Private->UfsHcBase + UFS_HC_UTRLDBR_OFFSET; 1068 Status = UfsWaitMemSet (Address, BIT0, 0, Packet.Timeout); 1069 if (EFI_ERROR (Status)) { 1070 goto Exit; 1071 } 1072 1073 if (QueryResp->QueryResp != 0) { 1074 DumpQueryResponseResult (QueryResp->QueryResp); 1075 Status = EFI_DEVICE_ERROR; 1076 goto Exit; 1077 } 1078 1079 if (Trd->Ocs == 0) { 1080 *Value = (UINT8)QueryResp->Tsf.Value; 1081 } else { 1082 Status = EFI_DEVICE_ERROR; 1083 } 1084 1085 Exit: 1086 UfsStopExecCmd (Private, Slot); 1087 UfsPeimFreeMem (Private->Pool, CmdDescBase, CmdDescSize); 1088 1089 return Status; 1090 } 1091 1092 /** 1093 Set specified flag to 1 on a UFS device. 1094 1095 @param[in] Private The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure. 1096 @param[in] FlagId The ID of flag to be set. 1097 1098 @retval EFI_SUCCESS The flag was set successfully. 1099 @retval EFI_DEVICE_ERROR A device error occurred while attempting to set the flag. 1100 @retval EFI_TIMEOUT A timeout occurred while waiting for the completion of setting the flag. 1101 1102 **/ 1103 EFI_STATUS 1104 UfsSetFlag ( 1105 IN UFS_PEIM_HC_PRIVATE_DATA *Private, 1106 IN UINT8 FlagId 1107 ) 1108 { 1109 EFI_STATUS Status; 1110 UINT8 Value; 1111 1112 Value = 1; 1113 Status = UfsRwFlags (Private, FALSE, FlagId, &Value); 1114 1115 return Status; 1116 } 1117 1118 /** 1119 Clear specified flag to 0 on a UFS device. 1120 1121 @param[in] Private The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure. 1122 @param[in] FlagId The ID of flag to be cleared. 1123 1124 @retval EFI_SUCCESS The flag was cleared successfully. 1125 @retval EFI_DEVICE_ERROR A device error occurred while attempting to clear the flag. 1126 @retval EFI_TIMEOUT A timeout occurred while waiting for the completion of clearing the flag. 1127 1128 **/ 1129 EFI_STATUS 1130 UfsClearFlag ( 1131 IN UFS_PEIM_HC_PRIVATE_DATA *Private, 1132 IN UINT8 FlagId 1133 ) 1134 { 1135 EFI_STATUS Status; 1136 UINT8 Value; 1137 1138 Value = 0; 1139 Status = UfsRwFlags (Private, FALSE, FlagId, &Value); 1140 1141 return Status; 1142 } 1143 1144 /** 1145 Read specified flag from a UFS device. 1146 1147 @param[in] Private The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure. 1148 @param[in] FlagId The ID of flag to be read. 1149 @param[out] Value The flag's value. 1150 1151 @retval EFI_SUCCESS The flag was read successfully. 1152 @retval EFI_DEVICE_ERROR A device error occurred while attempting to read the flag. 1153 @retval EFI_TIMEOUT A timeout occurred while waiting for the completion of reading the flag. 1154 1155 **/ 1156 EFI_STATUS 1157 UfsReadFlag ( 1158 IN UFS_PEIM_HC_PRIVATE_DATA *Private, 1159 IN UINT8 FlagId, 1160 OUT UINT8 *Value 1161 ) 1162 { 1163 EFI_STATUS Status; 1164 1165 Status = UfsRwFlags (Private, TRUE, FlagId, Value); 1166 1167 return Status; 1168 } 1169 1170 /** 1171 Sends NOP IN cmd to a UFS device for initialization process request. 1172 For more details, please refer to UFS 2.0 spec Figure 13.3. 1173 1174 @param[in] Private The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure. 1175 1176 @retval EFI_SUCCESS The NOP IN command was sent by the host. The NOP OUT response was 1177 received successfully. 1178 @retval EFI_DEVICE_ERROR A device error occurred while attempting to execute NOP IN command. 1179 @retval EFI_OUT_OF_RESOURCES The resource for transfer is not available. 1180 @retval EFI_TIMEOUT A timeout occurred while waiting for the NOP IN command to execute. 1181 1182 **/ 1183 EFI_STATUS 1184 UfsExecNopCmds ( 1185 IN UFS_PEIM_HC_PRIVATE_DATA *Private 1186 ) 1187 { 1188 EFI_STATUS Status; 1189 UINT8 Slot; 1190 UTP_TRD *Trd; 1191 UTP_NOP_IN_UPIU *NopInUpiu; 1192 UINT8 *CmdDescBase; 1193 UINT32 CmdDescSize; 1194 UINTN Address; 1195 1196 // 1197 // Find out which slot of transfer request list is available. 1198 // 1199 Status = UfsFindAvailableSlotInTrl (Private, &Slot); 1200 if (EFI_ERROR (Status)) { 1201 return Status; 1202 } 1203 1204 Trd = ((UTP_TRD*)Private->UtpTrlBase) + Slot; 1205 Status = UfsCreateNopCommandDesc (Private, Trd); 1206 if (EFI_ERROR (Status)) { 1207 return Status; 1208 } 1209 1210 // 1211 // Check the transfer request result. 1212 // 1213 CmdDescBase = (UINT8 *)(UINTN)(LShiftU64 ((UINT64)Trd->UcdBaU, 32) | LShiftU64 ((UINT64)Trd->UcdBa, 7)); 1214 NopInUpiu = (UTP_NOP_IN_UPIU*)(CmdDescBase + Trd->RuO * sizeof (UINT32)); 1215 CmdDescSize = Trd->RuO * sizeof (UINT32) + Trd->RuL * sizeof (UINT32); 1216 1217 // 1218 // Start to execute the transfer request. 1219 // 1220 UfsStartExecCmd (Private, Slot); 1221 1222 // 1223 // Wait for the completion of the transfer request. 1224 // 1225 Address = Private->UfsHcBase + UFS_HC_UTRLDBR_OFFSET; 1226 Status = UfsWaitMemSet (Address, BIT0, 0, UFS_TIMEOUT); 1227 if (EFI_ERROR (Status)) { 1228 goto Exit; 1229 } 1230 1231 if (NopInUpiu->Resp != 0) { 1232 Status = EFI_DEVICE_ERROR; 1233 } else { 1234 Status = EFI_SUCCESS; 1235 } 1236 1237 Exit: 1238 UfsStopExecCmd (Private, Slot); 1239 UfsPeimFreeMem (Private->Pool, CmdDescBase, CmdDescSize); 1240 1241 return Status; 1242 } 1243 1244 /** 1245 Sends a UFS-supported SCSI Request Packet to a UFS device that is attached to the UFS host controller. 1246 1247 @param[in] Private The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure. 1248 @param[in] Lun The LUN of the UFS device to send the SCSI Request Packet. 1249 @param[in, out] Packet A pointer to the SCSI Request Packet to send to a specified Lun of the 1250 UFS device. 1251 1252 @retval EFI_SUCCESS The SCSI Request Packet was sent by the host. For bi-directional 1253 commands, InTransferLength bytes were transferred from 1254 InDataBuffer. For write and bi-directional commands, 1255 OutTransferLength bytes were transferred by 1256 OutDataBuffer. 1257 @retval EFI_DEVICE_ERROR A device error occurred while attempting to send the SCSI Request 1258 Packet. 1259 @retval EFI_OUT_OF_RESOURCES The resource for transfer is not available. 1260 @retval EFI_TIMEOUT A timeout occurred while waiting for the SCSI Request Packet to execute. 1261 1262 **/ 1263 EFI_STATUS 1264 UfsExecScsiCmds ( 1265 IN UFS_PEIM_HC_PRIVATE_DATA *Private, 1266 IN UINT8 Lun, 1267 IN OUT UFS_SCSI_REQUEST_PACKET *Packet 1268 ) 1269 { 1270 EFI_STATUS Status; 1271 UINT8 Slot; 1272 UTP_TRD *Trd; 1273 UINTN Address; 1274 UINT8 *CmdDescBase; 1275 UINT32 CmdDescSize; 1276 UTP_RESPONSE_UPIU *Response; 1277 UINT16 SenseDataLen; 1278 UINT32 ResTranCount; 1279 1280 // 1281 // Find out which slot of transfer request list is available. 1282 // 1283 Status = UfsFindAvailableSlotInTrl (Private, &Slot); 1284 if (EFI_ERROR (Status)) { 1285 return Status; 1286 } 1287 1288 Trd = ((UTP_TRD*)Private->UtpTrlBase) + Slot; 1289 1290 // 1291 // Fill transfer request descriptor to this slot. 1292 // 1293 Status = UfsCreateScsiCommandDesc (Private, Lun, Packet, Trd); 1294 if (EFI_ERROR (Status)) { 1295 return Status; 1296 } 1297 1298 CmdDescBase = (UINT8*)(UINTN)(LShiftU64 ((UINT64)Trd->UcdBaU, 32) | LShiftU64 ((UINT64)Trd->UcdBa, 7)); 1299 CmdDescSize = Trd->PrdtO * sizeof (UINT32) + Trd->PrdtL * sizeof (UTP_TR_PRD); 1300 1301 // 1302 // Start to execute the transfer request. 1303 // 1304 UfsStartExecCmd (Private, Slot); 1305 1306 // 1307 // Wait for the completion of the transfer request. 1308 // 1309 Address = Private->UfsHcBase + UFS_HC_UTRLDBR_OFFSET; 1310 Status = UfsWaitMemSet (Address, BIT0, 0, Packet->Timeout); 1311 if (EFI_ERROR (Status)) { 1312 goto Exit; 1313 } 1314 1315 // 1316 // Get sense data if exists 1317 // 1318 Response = (UTP_RESPONSE_UPIU*)(CmdDescBase + Trd->RuO * sizeof (UINT32)); 1319 SenseDataLen = Response->SenseDataLen; 1320 SwapLittleEndianToBigEndian ((UINT8*)&SenseDataLen, sizeof (UINT16)); 1321 1322 if ((Packet->SenseDataLength != 0) && (Packet->SenseData != NULL)) { 1323 CopyMem (Packet->SenseData, Response->SenseData, SenseDataLen); 1324 Packet->SenseDataLength = (UINT8)SenseDataLen; 1325 } 1326 1327 // 1328 // Check the transfer request result. 1329 // 1330 if (Response->Response != 0) { 1331 DEBUG ((EFI_D_ERROR, "UfsExecScsiCmds() fails with Target Failure\n")); 1332 Status = EFI_DEVICE_ERROR; 1333 goto Exit; 1334 } 1335 1336 if (Trd->Ocs == 0) { 1337 if (Packet->DataDirection == UfsDataIn) { 1338 if ((Response->Flags & BIT5) == BIT5) { 1339 ResTranCount = Response->ResTranCount; 1340 SwapLittleEndianToBigEndian ((UINT8*)&ResTranCount, sizeof (UINT32)); 1341 Packet->InTransferLength -= ResTranCount; 1342 } 1343 } else if (Packet->DataDirection == UfsDataOut) { 1344 if ((Response->Flags & BIT5) == BIT5) { 1345 ResTranCount = Response->ResTranCount; 1346 SwapLittleEndianToBigEndian ((UINT8*)&ResTranCount, sizeof (UINT32)); 1347 Packet->OutTransferLength -= ResTranCount; 1348 } 1349 } 1350 } else { 1351 Status = EFI_DEVICE_ERROR; 1352 } 1353 1354 Exit: 1355 UfsStopExecCmd (Private, Slot); 1356 UfsPeimFreeMem (Private->Pool, CmdDescBase, CmdDescSize); 1357 1358 return Status; 1359 } 1360 1361 1362 /** 1363 Sent UIC DME_LINKSTARTUP command to start the link startup procedure. 1364 1365 @param[in] Private The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure. 1366 @param[in] UicOpcode The opcode of the UIC command. 1367 @param[in] Arg1 The value for 1st argument of the UIC command. 1368 @param[in] Arg2 The value for 2nd argument of the UIC command. 1369 @param[in] Arg3 The value for 3rd argument of the UIC command. 1370 1371 @return EFI_SUCCESS Successfully execute this UIC command and detect attached UFS device. 1372 @return EFI_DEVICE_ERROR Fail to execute this UIC command and detect attached UFS device. 1373 @return EFI_NOT_FOUND The presence of the UFS device isn't detected. 1374 1375 **/ 1376 EFI_STATUS 1377 UfsExecUicCommands ( 1378 IN UFS_PEIM_HC_PRIVATE_DATA *Private, 1379 IN UINT8 UicOpcode, 1380 IN UINT32 Arg1, 1381 IN UINT32 Arg2, 1382 IN UINT32 Arg3 1383 ) 1384 { 1385 EFI_STATUS Status; 1386 UINTN Address; 1387 UINT32 Data; 1388 UINTN UfsHcBase; 1389 1390 UfsHcBase = Private->UfsHcBase; 1391 Address = UfsHcBase + UFS_HC_IS_OFFSET; 1392 Data = MmioRead32 (Address); 1393 if ((Data & UFS_HC_IS_UCCS) == UFS_HC_IS_UCCS) { 1394 // 1395 // Clear IS.BIT10 UIC Command Completion Status (UCCS) at first. 1396 // 1397 MmioWrite32 (Address, Data); 1398 } 1399 1400 // 1401 // When programming UIC command registers, host software shall set the register UICCMD 1402 // only after all the UIC command argument registers (UICCMDARG1, UICCMDARG2 and UICCMDARG3) 1403 // are set. 1404 // 1405 Address = UfsHcBase + UFS_HC_UCMD_ARG1_OFFSET; 1406 MmioWrite32 (Address, Arg1); 1407 1408 Address = UfsHcBase + UFS_HC_UCMD_ARG2_OFFSET; 1409 MmioWrite32 (Address, Arg2); 1410 1411 Address = UfsHcBase + UFS_HC_UCMD_ARG3_OFFSET; 1412 MmioWrite32 (Address, Arg3); 1413 1414 // 1415 // Host software shall only set the UICCMD if HCS.UCRDY is set to 1. 1416 // 1417 Address = Private->UfsHcBase + UFS_HC_STATUS_OFFSET; 1418 Status = UfsWaitMemSet (Address, UFS_HC_HCS_UCRDY, UFS_HC_HCS_UCRDY, UFS_TIMEOUT); 1419 if (EFI_ERROR (Status)) { 1420 return Status; 1421 } 1422 1423 Address = UfsHcBase + UFS_HC_UIC_CMD_OFFSET; 1424 MmioWrite32 (Address, (UINT32)UicOpcode); 1425 1426 // 1427 // UFS 2.0 spec section 5.3.1 Offset:0x20 IS.Bit10 UIC Command Completion Status (UCCS) 1428 // This bit is set to '1' by the host controller upon completion of a UIC command. 1429 // 1430 Address = UfsHcBase + UFS_HC_IS_OFFSET; 1431 Data = MmioRead32 (Address); 1432 Status = UfsWaitMemSet (Address, UFS_HC_IS_UCCS, UFS_HC_IS_UCCS, UFS_TIMEOUT); 1433 if (EFI_ERROR (Status)) { 1434 return Status; 1435 } 1436 1437 if (UicOpcode != UfsUicDmeReset) { 1438 Address = UfsHcBase + UFS_HC_UCMD_ARG2_OFFSET; 1439 Data = MmioRead32 (Address); 1440 if ((Data & 0xFF) != 0) { 1441 DEBUG_CODE_BEGIN(); 1442 DumpUicCmdExecResult (UicOpcode, (UINT8)(Data & 0xFF)); 1443 DEBUG_CODE_END(); 1444 return EFI_DEVICE_ERROR; 1445 } 1446 } 1447 1448 // 1449 // Check value of HCS.DP and make sure that there is a device attached to the Link. 1450 // 1451 Address = UfsHcBase + UFS_HC_STATUS_OFFSET; 1452 Data = MmioRead32 (Address); 1453 if ((Data & UFS_HC_HCS_DP) == 0) { 1454 Address = UfsHcBase + UFS_HC_IS_OFFSET; 1455 Status = UfsWaitMemSet (Address, UFS_HC_IS_ULSS, UFS_HC_IS_ULSS, UFS_TIMEOUT); 1456 if (EFI_ERROR (Status)) { 1457 return EFI_DEVICE_ERROR; 1458 } 1459 return EFI_NOT_FOUND; 1460 } 1461 1462 DEBUG ((EFI_D_INFO, "UfsblockioPei: found a attached UFS device\n")); 1463 1464 return EFI_SUCCESS; 1465 } 1466 1467 /** 1468 Enable the UFS host controller for accessing. 1469 1470 @param[in] Private The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure. 1471 1472 @retval EFI_SUCCESS The UFS host controller enabling was executed successfully. 1473 @retval EFI_DEVICE_ERROR A device error occurred while enabling the UFS host controller. 1474 1475 **/ 1476 EFI_STATUS 1477 UfsEnableHostController ( 1478 IN UFS_PEIM_HC_PRIVATE_DATA *Private 1479 ) 1480 { 1481 EFI_STATUS Status; 1482 UINTN Address; 1483 UINT32 Data; 1484 1485 // 1486 // UFS 2.0 spec section 7.1.1 - Host Controller Initialization 1487 // 1488 // Reinitialize the UFS host controller if HCE bit of HC register is set. 1489 // 1490 Address = Private->UfsHcBase + UFS_HC_ENABLE_OFFSET; 1491 Data = MmioRead32 (Address); 1492 if ((Data & UFS_HC_HCE_EN) == UFS_HC_HCE_EN) { 1493 // 1494 // Write a 0 to the HCE register at first to disable the host controller. 1495 // 1496 MmioWrite32 (Address, 0); 1497 // 1498 // Wait until HCE is read as '0' before continuing. 1499 // 1500 Status = UfsWaitMemSet (Address, UFS_HC_HCE_EN, 0, UFS_TIMEOUT); 1501 if (EFI_ERROR (Status)) { 1502 return EFI_DEVICE_ERROR; 1503 } 1504 } 1505 1506 // 1507 // Write a 1 to the HCE register to enable the UFS host controller. 1508 // 1509 MmioWrite32 (Address, UFS_HC_HCE_EN); 1510 // 1511 // Wait until HCE is read as '1' before continuing. 1512 // 1513 Status = UfsWaitMemSet (Address, UFS_HC_HCE_EN, UFS_HC_HCE_EN, UFS_TIMEOUT); 1514 if (EFI_ERROR (Status)) { 1515 return EFI_DEVICE_ERROR; 1516 } 1517 1518 return EFI_SUCCESS; 1519 } 1520 1521 /** 1522 Detect if a UFS device attached. 1523 1524 @param[in] Private The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure. 1525 1526 @retval EFI_SUCCESS The UFS device detection was executed successfully. 1527 @retval EFI_NOT_FOUND Not found a UFS device attached. 1528 @retval EFI_DEVICE_ERROR A device error occurred while detecting the UFS device. 1529 1530 **/ 1531 EFI_STATUS 1532 UfsDeviceDetection ( 1533 IN UFS_PEIM_HC_PRIVATE_DATA *Private 1534 ) 1535 { 1536 UINTN Retry; 1537 EFI_STATUS Status; 1538 1539 // 1540 // Start UFS device detection. 1541 // Try up to 3 times for establishing data link with device. 1542 // 1543 for (Retry = 0; Retry < 3; Retry++) { 1544 Status = UfsExecUicCommands (Private, UfsUicDmeLinkStartup, 0, 0, 0); 1545 if (!EFI_ERROR (Status)) { 1546 break; 1547 } 1548 1549 if (Status == EFI_NOT_FOUND) { 1550 continue; 1551 } 1552 1553 return EFI_DEVICE_ERROR; 1554 } 1555 1556 if (Retry == 3) { 1557 return EFI_NOT_FOUND; 1558 } 1559 1560 return EFI_SUCCESS; 1561 } 1562 1563 /** 1564 Initialize UFS task management request list related h/w context. 1565 1566 @param[in] Private The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure. 1567 1568 @retval EFI_SUCCESS The UFS task management list was initialzed successfully. 1569 @retval EFI_DEVICE_ERROR The initialization fails. 1570 1571 **/ 1572 EFI_STATUS 1573 UfsInitTaskManagementRequestList ( 1574 IN UFS_PEIM_HC_PRIVATE_DATA *Private 1575 ) 1576 { 1577 UINTN Address; 1578 UINT32 Data; 1579 UINT8 Nutmrs; 1580 EFI_PHYSICAL_ADDRESS Buffer; 1581 EFI_STATUS Status; 1582 1583 // 1584 // Initial h/w and s/w context for future operations. 1585 // 1586 Address = Private->UfsHcBase + UFS_HC_CAP_OFFSET; 1587 Data = MmioRead32 (Address); 1588 Private->Capabilities = Data; 1589 1590 // 1591 // Allocate and initialize UTP Task Management Request List. 1592 // 1593 Nutmrs = (UINT8) (RShiftU64 ((Private->Capabilities & UFS_HC_CAP_NUTMRS), 16) + 1); 1594 Status = PeiServicesAllocatePages ( 1595 EfiBootServicesCode, 1596 EFI_SIZE_TO_PAGES (Nutmrs * sizeof (UTP_TMRD)), 1597 &Buffer 1598 ); 1599 1600 if (EFI_ERROR (Status)) { 1601 return EFI_DEVICE_ERROR; 1602 } 1603 1604 ZeroMem ((VOID*)(UINTN)Buffer, EFI_PAGES_TO_SIZE (EFI_SIZE_TO_PAGES (Nutmrs * sizeof (UTP_TMRD)))); 1605 1606 // 1607 // Program the UTP Task Management Request List Base Address and UTP Task Management 1608 // Request List Base Address with a 64-bit address allocated at step 6. 1609 // 1610 Address = Private->UfsHcBase + UFS_HC_UTMRLBA_OFFSET; 1611 MmioWrite32 (Address, (UINT32)(UINTN)Buffer); 1612 Address = Private->UfsHcBase + UFS_HC_UTMRLBAU_OFFSET; 1613 MmioWrite32 (Address, (UINT32)RShiftU64 ((UINT64)Buffer, 32)); 1614 Private->UtpTmrlBase = (VOID*)(UINTN)Buffer; 1615 Private->Nutmrs = Nutmrs; 1616 1617 // 1618 // Enable the UTP Task Management Request List by setting the UTP Task Management 1619 // Request List RunStop Register (UTMRLRSR) to '1'. 1620 // 1621 Address = Private->UfsHcBase + UFS_HC_UTMRLRSR_OFFSET; 1622 MmioWrite32 (Address, UFS_HC_UTMRLRSR); 1623 1624 return EFI_SUCCESS; 1625 } 1626 1627 /** 1628 Initialize UFS transfer request list related h/w context. 1629 1630 @param[in] Private The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure. 1631 1632 @retval EFI_SUCCESS The UFS transfer list was initialzed successfully. 1633 @retval EFI_DEVICE_ERROR The initialization fails. 1634 1635 **/ 1636 EFI_STATUS 1637 UfsInitTransferRequestList ( 1638 IN UFS_PEIM_HC_PRIVATE_DATA *Private 1639 ) 1640 { 1641 UINTN Address; 1642 UINT32 Data; 1643 UINT8 Nutrs; 1644 EFI_PHYSICAL_ADDRESS Buffer; 1645 EFI_STATUS Status; 1646 1647 // 1648 // Initial h/w and s/w context for future operations. 1649 // 1650 Address = Private->UfsHcBase + UFS_HC_CAP_OFFSET; 1651 Data = MmioRead32 (Address); 1652 Private->Capabilities = Data; 1653 1654 // 1655 // Allocate and initialize UTP Transfer Request List. 1656 // 1657 Nutrs = (UINT8)((Private->Capabilities & UFS_HC_CAP_NUTRS) + 1); 1658 Status = PeiServicesAllocatePages ( 1659 EfiBootServicesCode, 1660 EFI_SIZE_TO_PAGES (Nutrs * sizeof (UTP_TRD)), 1661 &Buffer 1662 ); 1663 1664 if (EFI_ERROR (Status)) { 1665 return EFI_DEVICE_ERROR; 1666 } 1667 1668 ZeroMem ((VOID*)(UINTN)Buffer, EFI_PAGES_TO_SIZE (EFI_SIZE_TO_PAGES (Nutrs * sizeof (UTP_TRD)))); 1669 1670 // 1671 // Program the UTP Transfer Request List Base Address and UTP Transfer Request List 1672 // Base Address with a 64-bit address allocated at step 8. 1673 // 1674 Address = Private->UfsHcBase + UFS_HC_UTRLBA_OFFSET; 1675 MmioWrite32 (Address, (UINT32)(UINTN)Buffer); 1676 Address = Private->UfsHcBase + UFS_HC_UTRLBAU_OFFSET; 1677 MmioWrite32 (Address, (UINT32)RShiftU64 ((UINT64)Buffer, 32)); 1678 Private->UtpTrlBase = (VOID*)(UINTN)Buffer; 1679 Private->Nutrs = Nutrs; 1680 1681 // 1682 // Enable the UTP Transfer Request List by setting the UTP Transfer Request List 1683 // RunStop Register (UTRLRSR) to '1'. 1684 // 1685 Address = Private->UfsHcBase + UFS_HC_UTRLRSR_OFFSET; 1686 MmioWrite32 (Address, UFS_HC_UTRLRSR); 1687 1688 return EFI_SUCCESS; 1689 } 1690 1691 /** 1692 Initialize the UFS host controller. 1693 1694 @param[in] Private The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure. 1695 1696 @retval EFI_SUCCESS The Ufs Host Controller is initialized successfully. 1697 @retval Others A device error occurred while initializing the controller. 1698 1699 **/ 1700 EFI_STATUS 1701 UfsControllerInit ( 1702 IN UFS_PEIM_HC_PRIVATE_DATA *Private 1703 ) 1704 { 1705 EFI_STATUS Status; 1706 1707 Status = UfsEnableHostController (Private); 1708 if (EFI_ERROR (Status)) { 1709 DEBUG ((EFI_D_ERROR, "UfsDevicePei: Enable Host Controller Fails, Status = %r\n", Status)); 1710 return Status; 1711 } 1712 1713 Status = UfsDeviceDetection (Private); 1714 if (EFI_ERROR (Status)) { 1715 DEBUG ((EFI_D_ERROR, "UfsDevicePei: Device Detection Fails, Status = %r\n", Status)); 1716 return Status; 1717 } 1718 1719 Status = UfsInitTaskManagementRequestList (Private); 1720 if (EFI_ERROR (Status)) { 1721 DEBUG ((EFI_D_ERROR, "UfsDevicePei: Task management list initialization Fails, Status = %r\n", Status)); 1722 return Status; 1723 } 1724 1725 Status = UfsInitTransferRequestList (Private); 1726 if (EFI_ERROR (Status)) { 1727 DEBUG ((EFI_D_ERROR, "UfsDevicePei: Transfer list initialization Fails, Status = %r\n", Status)); 1728 return Status; 1729 } 1730 1731 DEBUG ((EFI_D_INFO, "UfsDevicePei Finished\n")); 1732 return EFI_SUCCESS; 1733 } 1734 1735 /** 1736 Stop the UFS host controller. 1737 1738 @param[in] Private The pointer to the UFS_PEIM_HC_PRIVATE_DATA data structure. 1739 1740 @retval EFI_SUCCESS The Ufs Host Controller is stopped successfully. 1741 @retval Others A device error occurred while stopping the controller. 1742 1743 **/ 1744 EFI_STATUS 1745 UfsControllerStop ( 1746 IN UFS_PEIM_HC_PRIVATE_DATA *Private 1747 ) 1748 { 1749 EFI_STATUS Status; 1750 UINTN Address; 1751 UINT32 Data; 1752 1753 // 1754 // Enable the UTP Task Management Request List by setting the UTP Task Management 1755 // Request List RunStop Register (UTMRLRSR) to '1'. 1756 // 1757 Address = Private->UfsHcBase + UFS_HC_UTMRLRSR_OFFSET; 1758 MmioWrite32 (Address, 0); 1759 1760 // 1761 // Enable the UTP Transfer Request List by setting the UTP Transfer Request List 1762 // RunStop Register (UTRLRSR) to '1'. 1763 // 1764 Address = Private->UfsHcBase + UFS_HC_UTRLRSR_OFFSET; 1765 MmioWrite32 (Address, 0); 1766 1767 // 1768 // Write a 0 to the HCE register in order to disable the host controller. 1769 // 1770 Address = Private->UfsHcBase + UFS_HC_ENABLE_OFFSET; 1771 Data = MmioRead32 (Address); 1772 ASSERT ((Data & UFS_HC_HCE_EN) == UFS_HC_HCE_EN); 1773 MmioWrite32 (Address, 0); 1774 1775 // 1776 // Wait until HCE is read as '0' before continuing. 1777 // 1778 Status = UfsWaitMemSet (Address, UFS_HC_HCE_EN, 0, UFS_TIMEOUT); 1779 if (EFI_ERROR (Status)) { 1780 return EFI_DEVICE_ERROR; 1781 } 1782 1783 DEBUG ((EFI_D_INFO, "UfsDevicePei: Stop the UFS Host Controller\n")); 1784 1785 return EFI_SUCCESS; 1786 } 1787 1788
