1 /** @file 2 The SdDxe driver is used to manage the SD memory card device. 3 4 It produces BlockIo and BlockIo2 protocols to allow upper layer 5 access the SD memory card device. 6 7 Copyright (c) 2015 - 2016, Intel Corporation. All rights reserved.<BR> 8 This program and the accompanying materials 9 are licensed and made available under the terms and conditions of the BSD License 10 which accompanies this distribution. The full text of the license may be found at 11 http://opensource.org/licenses/bsd-license.php 12 13 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 14 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 15 16 **/ 17 18 #include "SdDxe.h" 19 20 // 21 // SdDxe Driver Binding Protocol Instance 22 // 23 EFI_DRIVER_BINDING_PROTOCOL gSdDxeDriverBinding = { 24 SdDxeDriverBindingSupported, 25 SdDxeDriverBindingStart, 26 SdDxeDriverBindingStop, 27 0x10, 28 NULL, 29 NULL 30 }; 31 32 // 33 // Template for SD_DEVICE data structure. 34 // 35 SD_DEVICE mSdDeviceTemplate = { 36 SD_DEVICE_SIGNATURE, // Signature 37 NULL, // Handle 38 NULL, // DevicePath 39 0xFF, // Slot 40 FALSE, // SectorAddressing 41 { // BlockIo 42 EFI_BLOCK_IO_PROTOCOL_REVISION, 43 NULL, 44 SdReset, 45 SdReadBlocks, 46 SdWriteBlocks, 47 SdFlushBlocks 48 }, 49 { // BlockIo2 50 NULL, 51 SdResetEx, 52 SdReadBlocksEx, 53 SdWriteBlocksEx, 54 SdFlushBlocksEx 55 }, 56 { // BlockMedia 57 0, // MediaId 58 FALSE, // RemovableMedia 59 TRUE, // MediaPresent 60 FALSE, // LogicPartition 61 FALSE, // ReadOnly 62 FALSE, // WritingCache 63 0x200, // BlockSize 64 0, // IoAlign 65 0 // LastBlock 66 }, 67 { // EraseBlock 68 EFI_ERASE_BLOCK_PROTOCOL_REVISION, 69 1, 70 SdEraseBlocks 71 }, 72 { // Queue 73 NULL, 74 NULL 75 }, 76 { // Csd 77 0, 78 }, 79 { // Cid 80 0, 81 }, 82 NULL, // ControllerNameTable 83 { // ModelName 84 0, 85 }, 86 NULL // Private 87 }; 88 89 /** 90 Decode and print SD CSD Register content. 91 92 @param[in] Csd Pointer to SD_CSD data structure. 93 94 @retval EFI_SUCCESS The function completed successfully 95 **/ 96 EFI_STATUS 97 DumpCsd ( 98 IN SD_CSD *Csd 99 ) 100 { 101 SD_CSD2 *Csd2; 102 103 DEBUG((DEBUG_INFO, "== Dump Sd Csd Register==\n")); 104 DEBUG((DEBUG_INFO, " CSD structure 0x%x\n", Csd->CsdStructure)); 105 DEBUG((DEBUG_INFO, " Data read access-time 1 0x%x\n", Csd->Taac)); 106 DEBUG((DEBUG_INFO, " Data read access-time 2 0x%x\n", Csd->Nsac)); 107 DEBUG((DEBUG_INFO, " Max. bus clock frequency 0x%x\n", Csd->TranSpeed)); 108 DEBUG((DEBUG_INFO, " Device command classes 0x%x\n", Csd->Ccc)); 109 DEBUG((DEBUG_INFO, " Max. read data block length 0x%x\n", Csd->ReadBlLen)); 110 DEBUG((DEBUG_INFO, " Partial blocks for read allowed 0x%x\n", Csd->ReadBlPartial)); 111 DEBUG((DEBUG_INFO, " Write block misalignment 0x%x\n", Csd->WriteBlkMisalign)); 112 DEBUG((DEBUG_INFO, " Read block misalignment 0x%x\n", Csd->ReadBlkMisalign)); 113 DEBUG((DEBUG_INFO, " DSR implemented 0x%x\n", Csd->DsrImp)); 114 if (Csd->CsdStructure == 0) { 115 DEBUG((DEBUG_INFO, " Device size 0x%x\n", Csd->CSizeLow | (Csd->CSizeHigh << 2))); 116 DEBUG((DEBUG_INFO, " Max. read current @ VDD min 0x%x\n", Csd->VddRCurrMin)); 117 DEBUG((DEBUG_INFO, " Max. read current @ VDD max 0x%x\n", Csd->VddRCurrMax)); 118 DEBUG((DEBUG_INFO, " Max. write current @ VDD min 0x%x\n", Csd->VddWCurrMin)); 119 DEBUG((DEBUG_INFO, " Max. write current @ VDD max 0x%x\n", Csd->VddWCurrMax)); 120 } else { 121 Csd2 = (SD_CSD2*)(VOID*)Csd; 122 DEBUG((DEBUG_INFO, " Device size 0x%x\n", Csd2->CSizeLow | (Csd->CSizeHigh << 16))); 123 } 124 DEBUG((DEBUG_INFO, " Erase sector size 0x%x\n", Csd->SectorSize)); 125 DEBUG((DEBUG_INFO, " Erase single block enable 0x%x\n", Csd->EraseBlkEn)); 126 DEBUG((DEBUG_INFO, " Write protect group size 0x%x\n", Csd->WpGrpSize)); 127 DEBUG((DEBUG_INFO, " Write protect group enable 0x%x\n", Csd->WpGrpEnable)); 128 DEBUG((DEBUG_INFO, " Write speed factor 0x%x\n", Csd->R2WFactor)); 129 DEBUG((DEBUG_INFO, " Max. write data block length 0x%x\n", Csd->WriteBlLen)); 130 DEBUG((DEBUG_INFO, " Partial blocks for write allowed 0x%x\n", Csd->WriteBlPartial)); 131 DEBUG((DEBUG_INFO, " File format group 0x%x\n", Csd->FileFormatGrp)); 132 DEBUG((DEBUG_INFO, " Copy flag (OTP) 0x%x\n", Csd->Copy)); 133 DEBUG((DEBUG_INFO, " Permanent write protection 0x%x\n", Csd->PermWriteProtect)); 134 DEBUG((DEBUG_INFO, " Temporary write protection 0x%x\n", Csd->TmpWriteProtect)); 135 DEBUG((DEBUG_INFO, " File format 0x%x\n", Csd->FileFormat)); 136 137 return EFI_SUCCESS; 138 } 139 140 /** 141 Get SD device model name. 142 143 @param[in, out] Device The pointer to the SD_DEVICE data structure. 144 @param[in] Cid Pointer to SD_CID data structure. 145 146 @retval EFI_SUCCESS The function completed successfully 147 148 **/ 149 EFI_STATUS 150 GetSdModelName ( 151 IN OUT SD_DEVICE *Device, 152 IN SD_CID *Cid 153 ) 154 { 155 CHAR8 String[SD_MODEL_NAME_MAX_LEN]; 156 157 ZeroMem (String, sizeof (String)); 158 CopyMem (String, Cid->OemId, sizeof (Cid->OemId)); 159 String[sizeof (Cid->OemId)] = ' '; 160 CopyMem (String + sizeof (Cid->OemId) + 1, Cid->ProductName, sizeof (Cid->ProductName)); 161 String[sizeof (Cid->OemId) + sizeof (Cid->ProductName)] = ' '; 162 CopyMem (String + sizeof (Cid->OemId) + sizeof (Cid->ProductName) + 1, Cid->ProductSerialNumber, sizeof (Cid->ProductSerialNumber)); 163 164 AsciiStrToUnicodeStrS (String, Device->ModelName, sizeof (Device->ModelName) / sizeof (Device->ModelName[0])); 165 166 return EFI_SUCCESS; 167 } 168 169 /** 170 Discover user area partition in the SD device. 171 172 @param[in] Device The pointer to the SD_DEVICE data structure. 173 174 @retval EFI_SUCCESS The user area partition in the SD device is successfully identified. 175 @return Others Some error occurs when identifying the user area. 176 177 **/ 178 EFI_STATUS 179 DiscoverUserArea ( 180 IN SD_DEVICE *Device 181 ) 182 { 183 EFI_STATUS Status; 184 SD_CSD *Csd; 185 SD_CSD2 *Csd2; 186 SD_CID *Cid; 187 UINT64 Capacity; 188 UINT32 DevStatus; 189 UINT16 Rca; 190 UINT32 CSize; 191 UINT32 CSizeMul; 192 UINT32 ReadBlLen; 193 194 // 195 // Deselect the device to force it enter stby mode. 196 // Note here we don't judge return status as some SD devices return 197 // error but the state has been stby. 198 // 199 SdSelect (Device, 0); 200 201 Status = SdSetRca (Device, &Rca); 202 if (EFI_ERROR (Status)) { 203 DEBUG ((EFI_D_ERROR, "DiscoverUserArea(): Assign new Rca = 0x%x fails with %r\n", Rca, Status)); 204 return Status; 205 } 206 207 Csd = &Device->Csd; 208 Status = SdGetCsd (Device, Rca, Csd); 209 if (EFI_ERROR (Status)) { 210 return Status; 211 } 212 DumpCsd (Csd); 213 214 Cid = &Device->Cid; 215 Status = SdGetCid (Device, Rca, Cid); 216 if (EFI_ERROR (Status)) { 217 return Status; 218 } 219 GetSdModelName (Device, Cid); 220 221 Status = SdSelect (Device, Rca); 222 if (EFI_ERROR (Status)) { 223 DEBUG ((EFI_D_ERROR, "DiscoverUserArea(): Reselect the device 0x%x fails with %r\n", Rca, Status)); 224 return Status; 225 } 226 227 Status = SdSendStatus (Device, Rca, &DevStatus); 228 if (EFI_ERROR (Status)) { 229 return Status; 230 } 231 232 if (Csd->CsdStructure == 0) { 233 Device->SectorAddressing = FALSE; 234 CSize = (Csd->CSizeHigh << 2 | Csd->CSizeLow) + 1; 235 CSizeMul = (1 << (Csd->CSizeMul + 2)); 236 ReadBlLen = (1 << (Csd->ReadBlLen)); 237 Capacity = MultU64x32 (MultU64x32 ((UINT64)CSize, CSizeMul), ReadBlLen); 238 } else { 239 Device->SectorAddressing = TRUE; 240 Csd2 = (SD_CSD2*)(VOID*)Csd; 241 CSize = (Csd2->CSizeHigh << 16 | Csd2->CSizeLow) + 1; 242 Capacity = MultU64x32 ((UINT64)CSize, SIZE_512KB); 243 } 244 245 Device->BlockIo.Media = &Device->BlockMedia; 246 Device->BlockIo2.Media = &Device->BlockMedia; 247 Device->BlockMedia.IoAlign = Device->Private->PassThru->IoAlign; 248 Device->BlockMedia.BlockSize = 0x200; 249 Device->BlockMedia.LastBlock = 0x00; 250 Device->BlockMedia.RemovableMedia = TRUE; 251 Device->BlockMedia.MediaPresent = TRUE; 252 Device->BlockMedia.LogicalPartition = FALSE; 253 Device->BlockMedia.LastBlock = DivU64x32 (Capacity, Device->BlockMedia.BlockSize) - 1; 254 255 if (Csd->EraseBlkEn) { 256 Device->EraseBlock.EraseLengthGranularity = 1; 257 } else { 258 Device->EraseBlock.EraseLengthGranularity = (Csd->SectorSize + 1) * (1 << (Csd->WriteBlLen - 9)); 259 } 260 261 return Status; 262 } 263 264 /** 265 Scan SD Bus to discover the device. 266 267 @param[in] Private The SD driver private data structure. 268 @param[in] Slot The slot number to check device present. 269 270 @retval EFI_SUCCESS Successfully to discover the device and attach 271 SdMmcIoProtocol to it. 272 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack 273 of resources. 274 @retval EFI_ALREADY_STARTED The device was discovered before. 275 @retval Others Fail to discover the device. 276 277 **/ 278 EFI_STATUS 279 EFIAPI 280 DiscoverSdDevice ( 281 IN SD_DRIVER_PRIVATE_DATA *Private, 282 IN UINT8 Slot 283 ) 284 { 285 EFI_STATUS Status; 286 SD_DEVICE *Device; 287 EFI_DEVICE_PATH_PROTOCOL *DevicePath; 288 EFI_DEVICE_PATH_PROTOCOL *NewDevicePath; 289 EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath; 290 EFI_HANDLE DeviceHandle; 291 EFI_SD_MMC_PASS_THRU_PROTOCOL *PassThru; 292 293 Device = NULL; 294 DevicePath = NULL; 295 NewDevicePath = NULL; 296 RemainingDevicePath = NULL; 297 PassThru = Private->PassThru; 298 299 // 300 // Build Device Path 301 // 302 Status = PassThru->BuildDevicePath ( 303 PassThru, 304 Slot, 305 &DevicePath 306 ); 307 if (EFI_ERROR(Status)) { 308 return Status; 309 } 310 311 if (DevicePath->SubType != MSG_SD_DP) { 312 Status = EFI_UNSUPPORTED; 313 goto Error; 314 } 315 316 NewDevicePath = AppendDevicePathNode ( 317 Private->ParentDevicePath, 318 DevicePath 319 ); 320 321 if (NewDevicePath == NULL) { 322 Status = EFI_OUT_OF_RESOURCES; 323 goto Error; 324 } 325 326 DeviceHandle = NULL; 327 RemainingDevicePath = NewDevicePath; 328 Status = gBS->LocateDevicePath (&gEfiDevicePathProtocolGuid, &RemainingDevicePath, &DeviceHandle); 329 if (!EFI_ERROR (Status) && (DeviceHandle != NULL) && IsDevicePathEnd(RemainingDevicePath)) { 330 // 331 // The device has been started, directly return to fast boot. 332 // 333 Status = EFI_ALREADY_STARTED; 334 goto Error; 335 } 336 337 // 338 // Allocate buffer to store SD_DEVICE private data. 339 // 340 Device = AllocateCopyPool (sizeof (SD_DEVICE), &mSdDeviceTemplate); 341 if (Device == NULL) { 342 Status = EFI_OUT_OF_RESOURCES; 343 goto Error; 344 } 345 346 Device->DevicePath = NewDevicePath; 347 Device->Slot = Slot; 348 Device->Private = Private; 349 InitializeListHead (&Device->Queue); 350 351 // 352 // Expose user area in the Sd memory card to upper layer. 353 // 354 Status = DiscoverUserArea (Device); 355 if (EFI_ERROR(Status)) { 356 goto Error; 357 } 358 359 Device->ControllerNameTable = NULL; 360 AddUnicodeString2 ( 361 "eng", 362 gSdDxeComponentName.SupportedLanguages, 363 &Device->ControllerNameTable, 364 Device->ModelName, 365 TRUE 366 ); 367 AddUnicodeString2 ( 368 "en", 369 gSdDxeComponentName.SupportedLanguages, 370 &Device->ControllerNameTable, 371 Device->ModelName, 372 FALSE 373 ); 374 375 Status = gBS->InstallMultipleProtocolInterfaces ( 376 &Device->Handle, 377 &gEfiDevicePathProtocolGuid, 378 Device->DevicePath, 379 &gEfiBlockIoProtocolGuid, 380 &Device->BlockIo, 381 &gEfiBlockIo2ProtocolGuid, 382 &Device->BlockIo2, 383 &gEfiEraseBlockProtocolGuid, 384 &Device->EraseBlock, 385 NULL 386 ); 387 388 if (!EFI_ERROR (Status)) { 389 gBS->OpenProtocol ( 390 Private->Controller, 391 &gEfiSdMmcPassThruProtocolGuid, 392 (VOID **) &(Private->PassThru), 393 Private->DriverBindingHandle, 394 Device->Handle, 395 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER 396 ); 397 } 398 399 Error: 400 FreePool (DevicePath); 401 402 if (EFI_ERROR (Status) && (NewDevicePath != NULL)) { 403 FreePool (NewDevicePath); 404 } 405 406 if (EFI_ERROR (Status) && (Device != NULL)) { 407 FreePool (Device); 408 } 409 410 return Status; 411 } 412 413 /** 414 Tests to see if this driver supports a given controller. If a child device is provided, 415 it further tests to see if this driver supports creating a handle for the specified child device. 416 417 This function checks to see if the driver specified by This supports the device specified by 418 ControllerHandle. Drivers will typically use the device path attached to 419 ControllerHandle and/or the services from the bus I/O abstraction attached to 420 ControllerHandle to determine if the driver supports ControllerHandle. This function 421 may be called many times during platform initialization. In order to reduce boot times, the tests 422 performed by this function must be very small, and take as little time as possible to execute. This 423 function must not change the state of any hardware devices, and this function must be aware that the 424 device specified by ControllerHandle may already be managed by the same driver or a 425 different driver. This function must match its calls to AllocatePages() with FreePages(), 426 AllocatePool() with FreePool(), and OpenProtocol() with CloseProtocol(). 427 Since ControllerHandle may have been previously started by the same driver, if a protocol is 428 already in the opened state, then it must not be closed with CloseProtocol(). This is required 429 to guarantee the state of ControllerHandle is not modified by this function. 430 431 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance. 432 @param[in] ControllerHandle The handle of the controller to test. This handle 433 must support a protocol interface that supplies 434 an I/O abstraction to the driver. 435 @param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This 436 parameter is ignored by device drivers, and is optional for bus 437 drivers. For bus drivers, if this parameter is not NULL, then 438 the bus driver must determine if the bus controller specified 439 by ControllerHandle and the child controller specified 440 by RemainingDevicePath are both supported by this 441 bus driver. 442 443 @retval EFI_SUCCESS The device specified by ControllerHandle and 444 RemainingDevicePath is supported by the driver specified by This. 445 @retval EFI_ALREADY_STARTED The device specified by ControllerHandle and 446 RemainingDevicePath is already being managed by the driver 447 specified by This. 448 @retval EFI_ACCESS_DENIED The device specified by ControllerHandle and 449 RemainingDevicePath is already being managed by a different 450 driver or an application that requires exclusive access. 451 Currently not implemented. 452 @retval EFI_UNSUPPORTED The device specified by ControllerHandle and 453 RemainingDevicePath is not supported by the driver specified by This. 454 **/ 455 EFI_STATUS 456 EFIAPI 457 SdDxeDriverBindingSupported ( 458 IN EFI_DRIVER_BINDING_PROTOCOL *This, 459 IN EFI_HANDLE Controller, 460 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath 461 ) 462 { 463 EFI_STATUS Status; 464 EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath; 465 EFI_SD_MMC_PASS_THRU_PROTOCOL *PassThru; 466 UINT8 Slot; 467 468 // 469 // Test EFI_SD_MMC_PASS_THRU_PROTOCOL on the controller handle. 470 // 471 Status = gBS->OpenProtocol ( 472 Controller, 473 &gEfiSdMmcPassThruProtocolGuid, 474 (VOID**) &PassThru, 475 This->DriverBindingHandle, 476 Controller, 477 EFI_OPEN_PROTOCOL_BY_DRIVER 478 ); 479 480 if (Status == EFI_ALREADY_STARTED) { 481 return EFI_SUCCESS; 482 } 483 484 if (EFI_ERROR (Status)) { 485 return Status; 486 } 487 488 // 489 // Test RemainingDevicePath is valid or not. 490 // 491 if ((RemainingDevicePath != NULL) && !IsDevicePathEnd (RemainingDevicePath)) { 492 Status = PassThru->GetSlotNumber (PassThru, RemainingDevicePath, &Slot); 493 if (EFI_ERROR (Status)) { 494 // 495 // Close the I/O Abstraction(s) used to perform the supported test 496 // 497 gBS->CloseProtocol ( 498 Controller, 499 &gEfiSdMmcPassThruProtocolGuid, 500 This->DriverBindingHandle, 501 Controller 502 ); 503 return Status; 504 } 505 } 506 507 // 508 // Close the I/O Abstraction(s) used to perform the supported test 509 // 510 gBS->CloseProtocol ( 511 Controller, 512 &gEfiSdMmcPassThruProtocolGuid, 513 This->DriverBindingHandle, 514 Controller 515 ); 516 517 // 518 // Open the EFI Device Path protocol needed to perform the supported test 519 // 520 Status = gBS->OpenProtocol ( 521 Controller, 522 &gEfiDevicePathProtocolGuid, 523 (VOID **) &ParentDevicePath, 524 This->DriverBindingHandle, 525 Controller, 526 EFI_OPEN_PROTOCOL_GET_PROTOCOL 527 ); 528 return Status; 529 } 530 531 /** 532 Starts a device controller or a bus controller. 533 534 The Start() function is designed to be invoked from the EFI boot service ConnectController(). 535 As a result, much of the error checking on the parameters to Start() has been moved into this 536 common boot service. It is legal to call Start() from other locations, 537 but the following calling restrictions must be followed or the system behavior will not be deterministic. 538 1. ControllerHandle must be a valid EFI_HANDLE. 539 2. If RemainingDevicePath is not NULL, then it must be a pointer to a naturally aligned 540 EFI_DEVICE_PATH_PROTOCOL. 541 3. Prior to calling Start(), the Supported() function for the driver specified by This must 542 have been called with the same calling parameters, and Supported() must have returned EFI_SUCCESS. 543 544 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance. 545 @param[in] ControllerHandle The handle of the controller to start. This handle 546 must support a protocol interface that supplies 547 an I/O abstraction to the driver. 548 @param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This 549 parameter is ignored by device drivers, and is optional for bus 550 drivers. For a bus driver, if this parameter is NULL, then handles 551 for all the children of Controller are created by this driver. 552 If this parameter is not NULL and the first Device Path Node is 553 not the End of Device Path Node, then only the handle for the 554 child device specified by the first Device Path Node of 555 RemainingDevicePath is created by this driver. 556 If the first Device Path Node of RemainingDevicePath is 557 the End of Device Path Node, no child handle is created by this 558 driver. 559 560 @retval EFI_SUCCESS The device was started. 561 @retval EFI_DEVICE_ERROR The device could not be started due to a device error.Currently not implemented. 562 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources. 563 @retval Others The driver failded to start the device. 564 565 **/ 566 EFI_STATUS 567 EFIAPI 568 SdDxeDriverBindingStart ( 569 IN EFI_DRIVER_BINDING_PROTOCOL *This, 570 IN EFI_HANDLE Controller, 571 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath 572 ) 573 { 574 EFI_STATUS Status; 575 EFI_SD_MMC_PASS_THRU_PROTOCOL *PassThru; 576 EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath; 577 SD_DRIVER_PRIVATE_DATA *Private; 578 UINT8 Slot; 579 580 Private = NULL; 581 PassThru = NULL; 582 Status = gBS->OpenProtocol ( 583 Controller, 584 &gEfiSdMmcPassThruProtocolGuid, 585 (VOID **) &PassThru, 586 This->DriverBindingHandle, 587 Controller, 588 EFI_OPEN_PROTOCOL_BY_DRIVER 589 ); 590 if ((EFI_ERROR (Status)) && (Status != EFI_ALREADY_STARTED)) { 591 return Status; 592 } 593 594 // 595 // Check EFI_ALREADY_STARTED to reuse the original SD_DRIVER_PRIVATE_DATA. 596 // 597 if (Status != EFI_ALREADY_STARTED) { 598 Private = AllocateZeroPool (sizeof (SD_DRIVER_PRIVATE_DATA)); 599 if (Private == NULL) { 600 Status = EFI_OUT_OF_RESOURCES; 601 goto Error; 602 } 603 604 Status = gBS->OpenProtocol ( 605 Controller, 606 &gEfiDevicePathProtocolGuid, 607 (VOID **) &ParentDevicePath, 608 This->DriverBindingHandle, 609 Controller, 610 EFI_OPEN_PROTOCOL_GET_PROTOCOL 611 ); 612 ASSERT_EFI_ERROR (Status); 613 Private->PassThru = PassThru; 614 Private->Controller = Controller; 615 Private->ParentDevicePath = ParentDevicePath; 616 Private->DriverBindingHandle = This->DriverBindingHandle; 617 618 Status = gBS->InstallProtocolInterface ( 619 &Controller, 620 &gEfiCallerIdGuid, 621 EFI_NATIVE_INTERFACE, 622 Private 623 ); 624 if (EFI_ERROR (Status)) { 625 goto Error; 626 } 627 } else { 628 Status = gBS->OpenProtocol ( 629 Controller, 630 &gEfiCallerIdGuid, 631 (VOID **) &Private, 632 This->DriverBindingHandle, 633 Controller, 634 EFI_OPEN_PROTOCOL_GET_PROTOCOL 635 ); 636 if (EFI_ERROR (Status)) { 637 goto Error; 638 } 639 } 640 641 if (RemainingDevicePath == NULL) { 642 Slot = 0xFF; 643 while (TRUE) { 644 Status = PassThru->GetNextSlot (PassThru, &Slot); 645 if (EFI_ERROR (Status)) { 646 // 647 // Cannot find more legal slots. 648 // 649 Status = EFI_SUCCESS; 650 break; 651 } 652 653 Status = DiscoverSdDevice (Private, Slot); 654 if (EFI_ERROR (Status) && (Status != EFI_ALREADY_STARTED)) { 655 break; 656 } 657 } 658 } else if (!IsDevicePathEnd (RemainingDevicePath)) { 659 Status = PassThru->GetSlotNumber (PassThru, RemainingDevicePath, &Slot); 660 if (!EFI_ERROR (Status)) { 661 Status = DiscoverSdDevice (Private, Slot); 662 } 663 } 664 665 Error: 666 if (EFI_ERROR (Status) && (Status != EFI_ALREADY_STARTED)) { 667 gBS->CloseProtocol ( 668 Controller, 669 &gEfiSdMmcPassThruProtocolGuid, 670 This->DriverBindingHandle, 671 Controller 672 ); 673 674 if (Private != NULL) { 675 gBS->UninstallMultipleProtocolInterfaces ( 676 Controller, 677 &gEfiCallerIdGuid, 678 Private, 679 NULL 680 ); 681 FreePool (Private); 682 } 683 } 684 return Status; 685 } 686 687 /** 688 Stops a device controller or a bus controller. 689 690 The Stop() function is designed to be invoked from the EFI boot service DisconnectController(). 691 As a result, much of the error checking on the parameters to Stop() has been moved 692 into this common boot service. It is legal to call Stop() from other locations, 693 but the following calling restrictions must be followed or the system behavior will not be deterministic. 694 1. ControllerHandle must be a valid EFI_HANDLE that was used on a previous call to this 695 same driver's Start() function. 696 2. The first NumberOfChildren handles of ChildHandleBuffer must all be a valid 697 EFI_HANDLE. In addition, all of these handles must have been created in this driver's 698 Start() function, and the Start() function must have called OpenProtocol() on 699 ControllerHandle with an Attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER. 700 701 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance. 702 @param[in] ControllerHandle A handle to the device being stopped. The handle must 703 support a bus specific I/O protocol for the driver 704 to use to stop the device. 705 @param[in] NumberOfChildren The number of child device handles in ChildHandleBuffer. 706 @param[in] ChildHandleBuffer An array of child handles to be freed. May be NULL 707 if NumberOfChildren is 0. 708 709 @retval EFI_SUCCESS The device was stopped. 710 @retval EFI_DEVICE_ERROR The device could not be stopped due to a device error. 711 712 **/ 713 EFI_STATUS 714 EFIAPI 715 SdDxeDriverBindingStop ( 716 IN EFI_DRIVER_BINDING_PROTOCOL *This, 717 IN EFI_HANDLE Controller, 718 IN UINTN NumberOfChildren, 719 IN EFI_HANDLE *ChildHandleBuffer 720 ) 721 { 722 EFI_STATUS Status; 723 BOOLEAN AllChildrenStopped; 724 UINTN Index; 725 SD_DRIVER_PRIVATE_DATA *Private; 726 SD_DEVICE *Device; 727 EFI_SD_MMC_PASS_THRU_PROTOCOL *PassThru; 728 EFI_BLOCK_IO2_PROTOCOL *BlockIo2; 729 EFI_BLOCK_IO_PROTOCOL *BlockIo; 730 LIST_ENTRY *Link; 731 LIST_ENTRY *NextLink; 732 SD_REQUEST *Request; 733 EFI_TPL OldTpl; 734 735 if (NumberOfChildren == 0) { 736 Status = gBS->OpenProtocol ( 737 Controller, 738 &gEfiCallerIdGuid, 739 (VOID **) &Private, 740 This->DriverBindingHandle, 741 Controller, 742 EFI_OPEN_PROTOCOL_GET_PROTOCOL 743 ); 744 if (EFI_ERROR (Status)) { 745 return EFI_DEVICE_ERROR; 746 } 747 748 gBS->UninstallProtocolInterface ( 749 Controller, 750 &gEfiCallerIdGuid, 751 Private 752 ); 753 gBS->CloseProtocol ( 754 Controller, 755 &gEfiSdMmcPassThruProtocolGuid, 756 This->DriverBindingHandle, 757 Controller 758 ); 759 760 FreePool (Private); 761 762 return EFI_SUCCESS; 763 } 764 765 AllChildrenStopped = TRUE; 766 767 for (Index = 0; Index < NumberOfChildren; Index++) { 768 BlockIo = NULL; 769 BlockIo2 = NULL; 770 Status = gBS->OpenProtocol ( 771 ChildHandleBuffer[Index], 772 &gEfiBlockIoProtocolGuid, 773 (VOID **) &BlockIo, 774 This->DriverBindingHandle, 775 Controller, 776 EFI_OPEN_PROTOCOL_GET_PROTOCOL 777 ); 778 if (EFI_ERROR (Status)) { 779 Status = gBS->OpenProtocol ( 780 ChildHandleBuffer[Index], 781 &gEfiBlockIo2ProtocolGuid, 782 (VOID **) &BlockIo2, 783 This->DriverBindingHandle, 784 Controller, 785 EFI_OPEN_PROTOCOL_GET_PROTOCOL 786 ); 787 if (EFI_ERROR (Status)) { 788 AllChildrenStopped = FALSE; 789 continue; 790 } 791 } 792 793 if (BlockIo != NULL) { 794 Device = SD_DEVICE_DATA_FROM_BLKIO (BlockIo); 795 } else { 796 ASSERT (BlockIo2 != NULL); 797 Device = SD_DEVICE_DATA_FROM_BLKIO2 (BlockIo2); 798 } 799 800 // 801 // Free all on-going async tasks. 802 // 803 OldTpl = gBS->RaiseTPL (TPL_NOTIFY); 804 for (Link = GetFirstNode (&Device->Queue); 805 !IsNull (&Device->Queue, Link); 806 Link = NextLink) { 807 NextLink = GetNextNode (&Device->Queue, Link); 808 RemoveEntryList (Link); 809 810 Request = SD_REQUEST_FROM_LINK (Link); 811 812 gBS->CloseEvent (Request->Event); 813 Request->Token->TransactionStatus = EFI_ABORTED; 814 815 if (Request->IsEnd) { 816 gBS->SignalEvent (Request->Token->Event); 817 } 818 819 FreePool (Request); 820 } 821 gBS->RestoreTPL (OldTpl); 822 823 // 824 // Close the child handle 825 // 826 Status = gBS->CloseProtocol ( 827 Controller, 828 &gEfiSdMmcPassThruProtocolGuid, 829 This->DriverBindingHandle, 830 ChildHandleBuffer[Index] 831 ); 832 833 Status = gBS->UninstallMultipleProtocolInterfaces ( 834 ChildHandleBuffer[Index], 835 &gEfiDevicePathProtocolGuid, 836 Device->DevicePath, 837 &gEfiBlockIoProtocolGuid, 838 &Device->BlockIo, 839 &gEfiBlockIo2ProtocolGuid, 840 &Device->BlockIo2, 841 &gEfiEraseBlockProtocolGuid, 842 &Device->EraseBlock, 843 NULL 844 ); 845 if (EFI_ERROR (Status)) { 846 AllChildrenStopped = FALSE; 847 gBS->OpenProtocol ( 848 Controller, 849 &gEfiSdMmcPassThruProtocolGuid, 850 (VOID **)&PassThru, 851 This->DriverBindingHandle, 852 ChildHandleBuffer[Index], 853 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER 854 ); 855 } else { 856 FreePool (Device->DevicePath); 857 FreeUnicodeStringTable (Device->ControllerNameTable); 858 FreePool (Device); 859 } 860 } 861 862 if (!AllChildrenStopped) { 863 return EFI_DEVICE_ERROR; 864 } 865 866 return EFI_SUCCESS; 867 } 868 869 /** 870 The user Entry Point for module SdDxe. The user code starts with this function. 871 872 @param[in] ImageHandle The firmware allocated handle for the EFI image. 873 @param[in] SystemTable A pointer to the EFI System Table. 874 875 @retval EFI_SUCCESS The entry point is executed successfully. 876 @retval other Some errors occur when executing this entry point. 877 878 **/ 879 EFI_STATUS 880 EFIAPI 881 InitializeSdDxe ( 882 IN EFI_HANDLE ImageHandle, 883 IN EFI_SYSTEM_TABLE *SystemTable 884 ) 885 { 886 EFI_STATUS Status; 887 888 // 889 // Install driver model protocol(s). 890 // 891 Status = EfiLibInstallDriverBindingComponentName2 ( 892 ImageHandle, 893 SystemTable, 894 &gSdDxeDriverBinding, 895 ImageHandle, 896 &gSdDxeComponentName, 897 &gSdDxeComponentName2 898 ); 899 ASSERT_EFI_ERROR (Status); 900 901 return Status; 902 } 903 904
