1 /** @file 2 Helper functions for configuring or getting the parameters relating to iSCSI. 3 4 Copyright (c) 2004 - 2015, Intel Corporation. All rights reserved.<BR> 5 This program and the accompanying materials 6 are licensed and made available under the terms and conditions of the BSD License 7 which accompanies this distribution. The full text of the license may be found at 8 http://opensource.org/licenses/bsd-license.php 9 10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 12 13 **/ 14 15 #include "IScsiImpl.h" 16 17 CHAR16 mVendorStorageName[] = L"ISCSI_CONFIG_IFR_NVDATA"; 18 BOOLEAN mIScsiDeviceListUpdated = FALSE; 19 UINTN mNumberOfIScsiDevices = 0; 20 ISCSI_FORM_CALLBACK_INFO *mCallbackInfo = NULL; 21 22 LIST_ENTRY mIScsiConfigFormList = { 23 &mIScsiConfigFormList, 24 &mIScsiConfigFormList 25 }; 26 27 HII_VENDOR_DEVICE_PATH mIScsiHiiVendorDevicePath = { 28 { 29 { 30 HARDWARE_DEVICE_PATH, 31 HW_VENDOR_DP, 32 { 33 (UINT8) (sizeof (VENDOR_DEVICE_PATH)), 34 (UINT8) ((sizeof (VENDOR_DEVICE_PATH)) >> 8) 35 } 36 }, 37 IP4_ISCSI_CONFIG_GUID 38 }, 39 { 40 END_DEVICE_PATH_TYPE, 41 END_ENTIRE_DEVICE_PATH_SUBTYPE, 42 { 43 (UINT8) (END_DEVICE_PATH_LENGTH), 44 (UINT8) ((END_DEVICE_PATH_LENGTH) >> 8) 45 } 46 } 47 }; 48 49 /** 50 Convert the IPv4 address into a dotted string. 51 52 @param[in] Ip The IPv4 address. 53 @param[out] Str The dotted IP string. 54 **/ 55 VOID 56 IScsiIpToStr ( 57 IN EFI_IPv4_ADDRESS *Ip, 58 OUT CHAR16 *Str 59 ) 60 { 61 UnicodeSPrint ( Str, 2 * IP4_STR_MAX_SIZE, L"%d.%d.%d.%d", Ip->Addr[0], Ip->Addr[1], Ip->Addr[2], Ip->Addr[3]); 62 } 63 64 65 /** 66 Parse IsId in string format and convert it to binary. 67 68 @param[in] String The buffer of the string to be parsed. 69 @param[in, out] IsId The buffer to store IsId. 70 71 @retval EFI_SUCCESS The operation finished successfully. 72 @retval EFI_INVALID_PARAMETER Any input parameter is invalid. 73 74 **/ 75 EFI_STATUS 76 IScsiParseIsIdFromString ( 77 IN CONST CHAR16 *String, 78 IN OUT UINT8 *IsId 79 ) 80 { 81 UINT8 Index; 82 CHAR16 *IsIdStr; 83 CHAR16 TempStr[3]; 84 UINTN NodeVal; 85 CHAR16 PortString[ISCSI_NAME_IFR_MAX_SIZE]; 86 EFI_INPUT_KEY Key; 87 88 if ((String == NULL) || (IsId == NULL)) { 89 return EFI_INVALID_PARAMETER; 90 } 91 92 IsIdStr = (CHAR16 *) String; 93 94 if (StrLen (IsIdStr) != 6) { 95 UnicodeSPrint ( 96 PortString, 97 (UINTN) sizeof (PortString), 98 L"Error! Input is incorrect, please input 6 hex numbers!\n" 99 ); 100 101 CreatePopUp ( 102 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, 103 &Key, 104 PortString, 105 NULL 106 ); 107 108 return EFI_INVALID_PARAMETER; 109 } 110 111 for (Index = 3; Index < 6; Index++) { 112 CopyMem (TempStr, IsIdStr, sizeof (TempStr)); 113 TempStr[2] = L'\0'; 114 115 // 116 // Convert the string to IsId. StrHexToUintn stops at the first character 117 // that is not a valid hex character, '\0' here. 118 // 119 NodeVal = StrHexToUintn (TempStr); 120 121 IsId[Index] = (UINT8) NodeVal; 122 123 IsIdStr = IsIdStr + 2; 124 } 125 126 return EFI_SUCCESS; 127 } 128 129 /** 130 Convert IsId from binary to string format. 131 132 @param[out] String The buffer to store the converted string. 133 @param[in] IsId The buffer to store IsId. 134 135 @retval EFI_SUCCESS The string converted successfully. 136 @retval EFI_INVALID_PARAMETER Any input parameter is invalid. 137 138 **/ 139 EFI_STATUS 140 IScsiConvertIsIdToString ( 141 OUT CHAR16 *String, 142 IN UINT8 *IsId 143 ) 144 { 145 UINT8 Index; 146 UINTN Number; 147 148 if ((String == NULL) || (IsId == NULL)) { 149 return EFI_INVALID_PARAMETER; 150 } 151 152 for (Index = 0; Index < 6; Index++) { 153 if (IsId[Index] <= 0xF) { 154 Number = UnicodeSPrint ( 155 String, 156 2 * ISID_CONFIGURABLE_STORAGE, 157 L"0%X", 158 (UINTN) IsId[Index] 159 ); 160 } else { 161 Number = UnicodeSPrint ( 162 String, 163 2 * ISID_CONFIGURABLE_STORAGE, 164 L"%X", 165 (UINTN) IsId[Index] 166 ); 167 168 } 169 170 String = String + Number; 171 } 172 173 *String = L'\0'; 174 175 return EFI_SUCCESS; 176 } 177 178 179 /** 180 Update the list of iSCSI devices the iSCSI driver is controlling. 181 182 @retval EFI_SUCCESS The callback successfully handled the action. 183 @retval Others Other errors as indicated. 184 **/ 185 EFI_STATUS 186 IScsiUpdateDeviceList ( 187 VOID 188 ) 189 { 190 EFI_STATUS Status; 191 ISCSI_DEVICE_LIST *DeviceList; 192 UINTN DataSize; 193 UINTN NumHandles; 194 EFI_HANDLE *Handles; 195 UINTN HandleIndex; 196 UINTN Index; 197 UINTN LastDeviceIndex; 198 EFI_MAC_ADDRESS MacAddress; 199 UINTN HwAddressSize; 200 UINT16 VlanId; 201 ISCSI_MAC_INFO *CurMacInfo; 202 ISCSI_MAC_INFO TempMacInfo; 203 CHAR16 MacString[70]; 204 UINTN DeviceListSize; 205 206 // 207 // Dump all the handles the Managed Network Service Binding Protocol is installed on. 208 // 209 Status = gBS->LocateHandleBuffer ( 210 ByProtocol, 211 &gEfiManagedNetworkServiceBindingProtocolGuid, 212 NULL, 213 &NumHandles, 214 &Handles 215 ); 216 if (EFI_ERROR (Status)) { 217 return Status; 218 } 219 220 DataSize = 0; 221 Status = gRT->GetVariable ( 222 L"iSCSIDeviceList", 223 &gIp4IScsiConfigGuid, 224 NULL, 225 &DataSize, 226 NULL 227 ); 228 if (Status == EFI_BUFFER_TOO_SMALL) { 229 DeviceList = (ISCSI_DEVICE_LIST *) AllocatePool (DataSize); 230 ASSERT (DeviceList != NULL); 231 232 gRT->GetVariable ( 233 L"iSCSIDeviceList", 234 &gIp4IScsiConfigGuid, 235 NULL, 236 &DataSize, 237 DeviceList 238 ); 239 240 LastDeviceIndex = 0; 241 242 for (HandleIndex = 0; HandleIndex < NumHandles; HandleIndex++) { 243 Status = NetLibGetMacAddress (Handles[HandleIndex], &MacAddress, &HwAddressSize); 244 ASSERT (Status == EFI_SUCCESS); 245 VlanId = NetLibGetVlanId (Handles[HandleIndex]); 246 247 for (Index = LastDeviceIndex; Index < DeviceList->NumDevice; Index++) { 248 CurMacInfo = &DeviceList->MacInfo[Index]; 249 if ((CurMacInfo->Len == HwAddressSize) && 250 (CurMacInfo->VlanId == VlanId) && 251 (NET_MAC_EQUAL (&CurMacInfo->Mac, MacAddress.Addr, HwAddressSize)) 252 ) { 253 // 254 // The previous configured NIC is still here. 255 // 256 if (Index != LastDeviceIndex) { 257 // 258 // Swap the current MAC address entry with the one indexed by 259 // LastDeviceIndex. 260 // 261 CopyMem (&TempMacInfo, CurMacInfo, sizeof (ISCSI_MAC_INFO)); 262 CopyMem (CurMacInfo, &DeviceList->MacInfo[LastDeviceIndex], sizeof (ISCSI_MAC_INFO)); 263 CopyMem (&DeviceList->MacInfo[LastDeviceIndex], &TempMacInfo, sizeof (ISCSI_MAC_INFO)); 264 } 265 266 LastDeviceIndex++; 267 } 268 } 269 270 if (LastDeviceIndex == DeviceList->NumDevice) { 271 break; 272 } 273 } 274 275 for (Index = LastDeviceIndex; Index < DeviceList->NumDevice; Index++) { 276 // 277 // delete the variables 278 // 279 CurMacInfo = &DeviceList->MacInfo[Index]; 280 IScsiMacAddrToStr (&CurMacInfo->Mac, CurMacInfo->Len, CurMacInfo->VlanId, MacString); 281 gRT->SetVariable (MacString, &gEfiIScsiInitiatorNameProtocolGuid, 0, 0, NULL); 282 gRT->SetVariable (MacString, &gIScsiCHAPAuthInfoGuid, 0, 0, NULL); 283 } 284 285 FreePool (DeviceList); 286 } else if (Status != EFI_NOT_FOUND) { 287 FreePool (Handles); 288 return Status; 289 } 290 // 291 // Construct the new iSCSI device list. 292 // 293 DeviceListSize = sizeof (ISCSI_DEVICE_LIST) + (NumHandles - 1) * sizeof (ISCSI_MAC_INFO); 294 DeviceList = (ISCSI_DEVICE_LIST *) AllocatePool (DeviceListSize); 295 ASSERT (DeviceList != NULL); 296 DeviceList->NumDevice = (UINT8) NumHandles; 297 298 for (Index = 0; Index < NumHandles; Index++) { 299 NetLibGetMacAddress (Handles[Index], &MacAddress, &HwAddressSize); 300 301 CurMacInfo = &DeviceList->MacInfo[Index]; 302 CopyMem (&CurMacInfo->Mac, MacAddress.Addr, HwAddressSize); 303 CurMacInfo->Len = (UINT8) HwAddressSize; 304 CurMacInfo->VlanId = NetLibGetVlanId (Handles[Index]); 305 } 306 307 gRT->SetVariable ( 308 L"iSCSIDeviceList", 309 &gIp4IScsiConfigGuid, 310 ISCSI_CONFIG_VAR_ATTR, 311 DeviceListSize, 312 DeviceList 313 ); 314 315 FreePool (DeviceList); 316 FreePool (Handles); 317 318 return Status; 319 } 320 321 /** 322 Get the iSCSI configuration form entry by the index of the goto opcode actived. 323 324 @param[in] Index The 0-based index of the goto opcode actived. 325 326 @return The iSCSI configuration form entry found. 327 **/ 328 ISCSI_CONFIG_FORM_ENTRY * 329 IScsiGetConfigFormEntryByIndex ( 330 IN UINT32 Index 331 ) 332 { 333 UINT32 CurrentIndex; 334 LIST_ENTRY *Entry; 335 ISCSI_CONFIG_FORM_ENTRY *ConfigFormEntry; 336 337 CurrentIndex = 0; 338 ConfigFormEntry = NULL; 339 340 NET_LIST_FOR_EACH (Entry, &mIScsiConfigFormList) { 341 if (CurrentIndex == Index) { 342 ConfigFormEntry = NET_LIST_USER_STRUCT (Entry, ISCSI_CONFIG_FORM_ENTRY, Link); 343 break; 344 } 345 346 CurrentIndex++; 347 } 348 349 return ConfigFormEntry; 350 } 351 352 /** 353 Convert the iSCSI configuration data into the IFR data. 354 355 @param[in] ConfigFormEntry The iSCSI configuration form entry. 356 @param[out] IfrNvData The IFR nv data. 357 358 **/ 359 VOID 360 IScsiConvertDeviceConfigDataToIfrNvData ( 361 IN ISCSI_CONFIG_FORM_ENTRY *ConfigFormEntry, 362 OUT ISCSI_CONFIG_IFR_NVDATA *IfrNvData 363 ) 364 { 365 ISCSI_SESSION_CONFIG_NVDATA *SessionConfigData; 366 ISCSI_CHAP_AUTH_CONFIG_NVDATA *AuthConfigData; 367 368 // 369 // Normal session configuration parameters. 370 // 371 SessionConfigData = &ConfigFormEntry->SessionConfigData; 372 IfrNvData->Enabled = SessionConfigData->Enabled; 373 374 IfrNvData->InitiatorInfoFromDhcp = SessionConfigData->InitiatorInfoFromDhcp; 375 IfrNvData->TargetInfoFromDhcp = SessionConfigData->TargetInfoFromDhcp; 376 IfrNvData->TargetPort = SessionConfigData->TargetPort; 377 378 IScsiIpToStr (&SessionConfigData->LocalIp, IfrNvData->LocalIp); 379 IScsiIpToStr (&SessionConfigData->SubnetMask, IfrNvData->SubnetMask); 380 IScsiIpToStr (&SessionConfigData->Gateway, IfrNvData->Gateway); 381 IScsiIpToStr (&SessionConfigData->TargetIp, IfrNvData->TargetIp); 382 383 IScsiAsciiStrToUnicodeStr (SessionConfigData->TargetName, IfrNvData->TargetName); 384 385 IScsiLunToUnicodeStr (SessionConfigData->BootLun, IfrNvData->BootLun); 386 387 IScsiConvertIsIdToString (IfrNvData->IsId, SessionConfigData->IsId); 388 389 // 390 // CHAP authentication parameters. 391 // 392 AuthConfigData = &ConfigFormEntry->AuthConfigData; 393 394 IfrNvData->CHAPType = AuthConfigData->CHAPType; 395 396 IScsiAsciiStrToUnicodeStr (AuthConfigData->CHAPName, IfrNvData->CHAPName); 397 IScsiAsciiStrToUnicodeStr (AuthConfigData->CHAPSecret, IfrNvData->CHAPSecret); 398 IScsiAsciiStrToUnicodeStr (AuthConfigData->ReverseCHAPName, IfrNvData->ReverseCHAPName); 399 IScsiAsciiStrToUnicodeStr (AuthConfigData->ReverseCHAPSecret, IfrNvData->ReverseCHAPSecret); 400 } 401 402 /** 403 This function allows the caller to request the current 404 configuration for one or more named elements. The resulting 405 string is in <ConfigAltResp> format. Any and all alternative 406 configuration strings shall also be appended to the end of the 407 current configuration string. If they are, they must appear 408 after the current configuration. They must contain the same 409 routing (GUID, NAME, PATH) as the current configuration string. 410 They must have an additional description indicating the type of 411 alternative configuration the string represents, 412 "ALTCFG=<StringToken>". That <StringToken> (when 413 converted from Hex UNICODE to binary) is a reference to a 414 string in the associated string pack. 415 416 @param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL. 417 @param[in] Request A null-terminated Unicode string in 418 <ConfigRequest> format. Note that this 419 includes the routing information as well as 420 the configurable name / value pairs. It is 421 invalid for this string to be in 422 <MultiConfigRequest> format. 423 @param[out] Progress On return, points to a character in the 424 Request string. Points to the string's null 425 terminator if request was successful. Points 426 to the most recent "&" before the first 427 failing name / value pair (or the beginning 428 of the string if the failure is in the first 429 name / value pair) if the request was not 430 successful. 431 @param[out] Results A null-terminated Unicode string in 432 <ConfigAltResp> format which has all values 433 filled in for the names in the Request string. 434 String to be allocated by the called function. 435 436 @retval EFI_SUCCESS The Results string is filled with the 437 values corresponding to all requested 438 names. 439 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the 440 parts of the results that must be 441 stored awaiting possible future 442 protocols. 443 @retval EFI_INVALID_PARAMETER For example, passing in a NULL 444 for the Request parameter 445 would result in this type of 446 error. In this case, the 447 Progress parameter would be 448 set to NULL. 449 @retval EFI_NOT_FOUND Routing data doesn't match any 450 known driver. Progress set to the 451 first character in the routing header. 452 Note: There is no requirement that the 453 driver validate the routing data. It 454 must skip the <ConfigHdr> in order to 455 process the names. 456 @retval EFI_INVALID_PARAMETER Illegal syntax. Progress set 457 to most recent & before the 458 error or the beginning of the 459 string. 460 @retval EFI_INVALID_PARAMETER Unknown name. Progress points 461 to the & before the name in 462 question.Currently not implemented. 463 **/ 464 EFI_STATUS 465 EFIAPI 466 IScsiFormExtractConfig ( 467 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This, 468 IN CONST EFI_STRING Request, 469 OUT EFI_STRING *Progress, 470 OUT EFI_STRING *Results 471 ) 472 { 473 EFI_STATUS Status; 474 CHAR8 InitiatorName[ISCSI_NAME_MAX_SIZE]; 475 UINTN BufferSize; 476 ISCSI_CONFIG_IFR_NVDATA *IfrNvData; 477 ISCSI_FORM_CALLBACK_INFO *Private; 478 EFI_HII_CONFIG_ROUTING_PROTOCOL *HiiConfigRouting; 479 EFI_STRING ConfigRequestHdr; 480 EFI_STRING ConfigRequest; 481 BOOLEAN AllocatedRequest; 482 UINTN Size; 483 484 if (Progress == NULL || Results == NULL) { 485 return EFI_INVALID_PARAMETER; 486 } 487 488 *Progress = Request; 489 if ((Request != NULL) && !HiiIsConfigHdrMatch (Request, &gIp4IScsiConfigGuid, mVendorStorageName)) { 490 return EFI_NOT_FOUND; 491 } 492 493 ConfigRequestHdr = NULL; 494 ConfigRequest = NULL; 495 AllocatedRequest = FALSE; 496 Size = 0; 497 498 if (!mIScsiDeviceListUpdated) { 499 // 500 // Update the device list. 501 // 502 IScsiUpdateDeviceList (); 503 mIScsiDeviceListUpdated = TRUE; 504 } 505 506 Private = ISCSI_FORM_CALLBACK_INFO_FROM_FORM_CALLBACK (This); 507 IfrNvData = AllocateZeroPool (sizeof (ISCSI_CONFIG_IFR_NVDATA)); 508 ASSERT (IfrNvData != NULL); 509 if (Private->Current != NULL) { 510 IScsiConvertDeviceConfigDataToIfrNvData (Private->Current, IfrNvData); 511 } 512 513 BufferSize = ISCSI_NAME_MAX_SIZE; 514 Status = gIScsiInitiatorName.Get (&gIScsiInitiatorName, &BufferSize, InitiatorName); 515 if (EFI_ERROR (Status)) { 516 IfrNvData->InitiatorName[0] = L'\0'; 517 } else { 518 IScsiAsciiStrToUnicodeStr (InitiatorName, IfrNvData->InitiatorName); 519 } 520 521 // 522 // Convert buffer data to <ConfigResp> by helper function BlockToConfig() 523 // 524 HiiConfigRouting = Private->ConfigRouting; 525 BufferSize = sizeof (ISCSI_CONFIG_IFR_NVDATA); 526 ConfigRequest = Request; 527 if ((Request == NULL) || (StrStr (Request, L"OFFSET") == NULL)) { 528 // 529 // Request has no request element, construct full request string. 530 // Allocate and fill a buffer large enough to hold the <ConfigHdr> template 531 // followed by "&OFFSET=0&WIDTH=WWWWWWWWWWWWWWWW" followed by a Null-terminator 532 // 533 ConfigRequestHdr = HiiConstructConfigHdr (&gIp4IScsiConfigGuid, mVendorStorageName, Private->DriverHandle); 534 Size = (StrLen (ConfigRequestHdr) + 32 + 1) * sizeof (CHAR16); 535 ConfigRequest = AllocateZeroPool (Size); 536 ASSERT (ConfigRequest != NULL); 537 AllocatedRequest = TRUE; 538 UnicodeSPrint (ConfigRequest, Size, L"%s&OFFSET=0&WIDTH=%016LX", ConfigRequestHdr, (UINT64)BufferSize); 539 FreePool (ConfigRequestHdr); 540 } 541 Status = HiiConfigRouting->BlockToConfig ( 542 HiiConfigRouting, 543 ConfigRequest, 544 (UINT8 *) IfrNvData, 545 BufferSize, 546 Results, 547 Progress 548 ); 549 FreePool (IfrNvData); 550 // 551 // Free the allocated config request string. 552 // 553 if (AllocatedRequest) { 554 FreePool (ConfigRequest); 555 ConfigRequest = NULL; 556 } 557 558 // 559 // Set Progress string to the original request string. 560 // 561 if (Request == NULL) { 562 *Progress = NULL; 563 } else if (StrStr (Request, L"OFFSET") == NULL) { 564 *Progress = Request + StrLen (Request); 565 } 566 567 return Status; 568 } 569 570 /** 571 This function applies changes in a driver's configuration. 572 Input is a Configuration, which has the routing data for this 573 driver followed by name / value configuration pairs. The driver 574 must apply those pairs to its configurable storage. If the 575 driver's configuration is stored in a linear block of data 576 and the driver's name / value pairs are in <BlockConfig> 577 format, it may use the ConfigToBlock helper function (above) to 578 simplify the job. Currently not implemented. 579 580 @param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL. 581 @param[in] Configuration A null-terminated Unicode string in 582 <ConfigString> format. 583 @param[out] Progress A pointer to a string filled in with the 584 offset of the most recent '&' before the 585 first failing name / value pair (or the 586 beginn ing of the string if the failure 587 is in the first name / value pair) or 588 the terminating NULL if all was 589 successful. 590 591 @retval EFI_SUCCESS The results have been distributed or are 592 awaiting distribution. 593 @retval EFI_OUT_OF_RESOURCES Not enough memory to store the 594 parts of the results that must be 595 stored awaiting possible future 596 protocols. 597 @retval EFI_INVALID_PARAMETERS Passing in a NULL for the 598 Results parameter would result 599 in this type of error. 600 @retval EFI_NOT_FOUND Target for the specified routing data 601 was not found. 602 **/ 603 EFI_STATUS 604 EFIAPI 605 IScsiFormRouteConfig ( 606 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This, 607 IN CONST EFI_STRING Configuration, 608 OUT EFI_STRING *Progress 609 ) 610 { 611 if (Configuration == NULL || Progress == NULL) { 612 return EFI_INVALID_PARAMETER; 613 } 614 615 // 616 // Check routing data in <ConfigHdr>. 617 // Note: if only one Storage is used, then this checking could be skipped. 618 // 619 if (!HiiIsConfigHdrMatch (Configuration, &gIp4IScsiConfigGuid, mVendorStorageName)) { 620 *Progress = Configuration; 621 return EFI_NOT_FOUND; 622 } 623 624 *Progress = Configuration + StrLen (Configuration); 625 return EFI_SUCCESS; 626 } 627 628 /** 629 This function is called to provide results data to the driver. 630 This data consists of a unique key that is used to identify 631 which data is either being passed back or being asked for. 632 633 @param[in] This Points to the EFI_HII_CONFIG_ACCESS_PROTOCOL. 634 @param[in] Action Specifies the type of action taken by the browser. 635 @param[in] QuestionId A unique value which is sent to the original 636 exporting driver so that it can identify the type 637 of data to expect. The format of the data tends to 638 vary based on the opcode that enerated the callback. 639 @param[in] Type The type of value for the question. 640 @param[in] Value A pointer to the data being sent to the original 641 exporting driver. 642 @param[out] ActionRequest On return, points to the action requested by the 643 callback function. 644 645 @retval EFI_SUCCESS The callback successfully handled the action. 646 @retval EFI_OUT_OF_RESOURCES Not enough storage is available to hold the 647 variable and its data. 648 @retval EFI_DEVICE_ERROR The variable could not be saved. 649 @retval EFI_UNSUPPORTED The specified Action is not supported by the 650 callback.Currently not implemented. 651 @retval EFI_INVALID_PARAMETERS Passing in wrong parameter. 652 @retval Others Other errors as indicated. 653 **/ 654 EFI_STATUS 655 EFIAPI 656 IScsiFormCallback ( 657 IN CONST EFI_HII_CONFIG_ACCESS_PROTOCOL *This, 658 IN EFI_BROWSER_ACTION Action, 659 IN EFI_QUESTION_ID QuestionId, 660 IN UINT8 Type, 661 IN EFI_IFR_TYPE_VALUE *Value, 662 OUT EFI_BROWSER_ACTION_REQUEST *ActionRequest 663 ) 664 { 665 ISCSI_FORM_CALLBACK_INFO *Private; 666 UINTN BufferSize; 667 CHAR8 IScsiName[ISCSI_NAME_MAX_SIZE]; 668 CHAR16 PortString[128]; 669 CHAR8 Ip4String[IP4_STR_MAX_SIZE]; 670 CHAR8 LunString[ISCSI_LUN_STR_MAX_LEN]; 671 UINT64 Lun; 672 EFI_STRING_ID DeviceFormTitleToken; 673 ISCSI_CONFIG_IFR_NVDATA *IfrNvData; 674 ISCSI_CONFIG_FORM_ENTRY *ConfigFormEntry; 675 EFI_IP_ADDRESS HostIp; 676 EFI_IP_ADDRESS SubnetMask; 677 EFI_IP_ADDRESS Gateway; 678 EFI_STATUS Status; 679 EFI_INPUT_KEY Key; 680 681 if (Action != EFI_BROWSER_ACTION_CHANGING && Action != EFI_BROWSER_ACTION_CHANGED) { 682 return EFI_UNSUPPORTED; 683 } 684 685 Private = ISCSI_FORM_CALLBACK_INFO_FROM_FORM_CALLBACK (This); 686 // 687 // Retrive uncommitted data from Browser 688 // 689 IfrNvData = AllocateZeroPool (sizeof (ISCSI_CONFIG_IFR_NVDATA)); 690 ASSERT (IfrNvData != NULL); 691 if (!HiiGetBrowserData (&gIp4IScsiConfigGuid, mVendorStorageName, sizeof (ISCSI_CONFIG_IFR_NVDATA), (UINT8 *) IfrNvData)) { 692 FreePool (IfrNvData); 693 return EFI_NOT_FOUND; 694 } 695 Status = EFI_SUCCESS; 696 697 if (Action == EFI_BROWSER_ACTION_CHANGING) { 698 if ((QuestionId >= KEY_DEVICE_ENTRY_BASE) && (QuestionId < (mNumberOfIScsiDevices + KEY_DEVICE_ENTRY_BASE))) { 699 // 700 // In case goto the device configuration form, update the device form title. 701 // 702 ConfigFormEntry = IScsiGetConfigFormEntryByIndex ((UINT32) (QuestionId - KEY_DEVICE_ENTRY_BASE)); 703 ASSERT (ConfigFormEntry != NULL); 704 705 UnicodeSPrint (PortString, (UINTN) sizeof (PortString), L"Port %s", ConfigFormEntry->MacString); 706 DeviceFormTitleToken = (EFI_STRING_ID) STR_ISCSI_DEVICE_FORM_TITLE; 707 HiiSetString (Private->RegisteredHandle, DeviceFormTitleToken, PortString, NULL); 708 709 IScsiConvertDeviceConfigDataToIfrNvData (ConfigFormEntry, IfrNvData); 710 711 Private->Current = ConfigFormEntry; 712 } 713 } else if (Action == EFI_BROWSER_ACTION_CHANGED) { 714 switch (QuestionId) { 715 case KEY_INITIATOR_NAME: 716 IScsiUnicodeStrToAsciiStr (IfrNvData->InitiatorName, IScsiName); 717 BufferSize = AsciiStrSize (IScsiName); 718 719 Status = gIScsiInitiatorName.Set (&gIScsiInitiatorName, &BufferSize, IScsiName); 720 if (EFI_ERROR (Status)) { 721 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, L"Invalid iSCSI Name!", NULL); 722 } 723 724 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_APPLY; 725 break; 726 727 case KEY_LOCAL_IP: 728 IScsiUnicodeStrToAsciiStr (IfrNvData->LocalIp, Ip4String); 729 Status = IScsiAsciiStrToIp (Ip4String, &HostIp.v4); 730 if (EFI_ERROR (Status) || !NetIp4IsUnicast (NTOHL (HostIp.Addr[0]), 0)) { 731 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, L"Invalid IP address!", NULL); 732 Status = EFI_INVALID_PARAMETER; 733 } else { 734 CopyMem (&Private->Current->SessionConfigData.LocalIp, &HostIp.v4, sizeof (HostIp.v4)); 735 } 736 737 break; 738 739 case KEY_SUBNET_MASK: 740 IScsiUnicodeStrToAsciiStr (IfrNvData->SubnetMask, Ip4String); 741 Status = IScsiAsciiStrToIp (Ip4String, &SubnetMask.v4); 742 if (EFI_ERROR (Status) || ((SubnetMask.Addr[0] != 0) && (IScsiGetSubnetMaskPrefixLength (&SubnetMask.v4) == 0))) { 743 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, L"Invalid Subnet Mask!", NULL); 744 Status = EFI_INVALID_PARAMETER; 745 } else { 746 CopyMem (&Private->Current->SessionConfigData.SubnetMask, &SubnetMask.v4, sizeof (SubnetMask.v4)); 747 } 748 749 break; 750 751 case KEY_GATE_WAY: 752 IScsiUnicodeStrToAsciiStr (IfrNvData->Gateway, Ip4String); 753 Status = IScsiAsciiStrToIp (Ip4String, &Gateway.v4); 754 if (EFI_ERROR (Status) || ((Gateway.Addr[0] != 0) && !NetIp4IsUnicast (NTOHL (Gateway.Addr[0]), 0))) { 755 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, L"Invalid Gateway!", NULL); 756 Status = EFI_INVALID_PARAMETER; 757 } else { 758 CopyMem (&Private->Current->SessionConfigData.Gateway, &Gateway.v4, sizeof (Gateway.v4)); 759 } 760 761 break; 762 763 case KEY_TARGET_IP: 764 IScsiUnicodeStrToAsciiStr (IfrNvData->TargetIp, Ip4String); 765 Status = IScsiAsciiStrToIp (Ip4String, &HostIp.v4); 766 if (EFI_ERROR (Status) || !NetIp4IsUnicast (NTOHL (HostIp.Addr[0]), 0)) { 767 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, L"Invalid IP address!", NULL); 768 Status = EFI_INVALID_PARAMETER; 769 } else { 770 CopyMem (&Private->Current->SessionConfigData.TargetIp, &HostIp.v4, sizeof (HostIp.v4)); 771 } 772 773 break; 774 775 case KEY_TARGET_NAME: 776 IScsiUnicodeStrToAsciiStr (IfrNvData->TargetName, IScsiName); 777 Status = IScsiNormalizeName (IScsiName, AsciiStrLen (IScsiName)); 778 if (EFI_ERROR (Status)) { 779 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, L"Invalid iSCSI Name!", NULL); 780 } else { 781 AsciiStrCpyS (Private->Current->SessionConfigData.TargetName, ISCSI_NAME_MAX_SIZE, IScsiName); 782 } 783 784 break; 785 786 case KEY_DHCP_ENABLE: 787 if (IfrNvData->InitiatorInfoFromDhcp == 0) { 788 IfrNvData->TargetInfoFromDhcp = 0; 789 } 790 791 break; 792 793 case KEY_BOOT_LUN: 794 IScsiUnicodeStrToAsciiStr (IfrNvData->BootLun, LunString); 795 Status = IScsiAsciiStrToLun (LunString, (UINT8 *) &Lun); 796 if (EFI_ERROR (Status)) { 797 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, L"Invalid LUN string!", NULL); 798 } else { 799 CopyMem (Private->Current->SessionConfigData.BootLun, &Lun, sizeof (Lun)); 800 } 801 802 break; 803 804 case KEY_CHAP_NAME: 805 IScsiUnicodeStrToAsciiStr (IfrNvData->CHAPName, Private->Current->AuthConfigData.CHAPName); 806 break; 807 808 case KEY_CHAP_SECRET: 809 IScsiUnicodeStrToAsciiStr (IfrNvData->CHAPSecret, Private->Current->AuthConfigData.CHAPSecret); 810 break; 811 812 case KEY_REVERSE_CHAP_NAME: 813 IScsiUnicodeStrToAsciiStr (IfrNvData->ReverseCHAPName, Private->Current->AuthConfigData.ReverseCHAPName); 814 break; 815 816 case KEY_REVERSE_CHAP_SECRET: 817 IScsiUnicodeStrToAsciiStr (IfrNvData->ReverseCHAPSecret, Private->Current->AuthConfigData.ReverseCHAPSecret); 818 break; 819 820 case KEY_CONFIG_ISID: 821 IScsiParseIsIdFromString (IfrNvData->IsId, Private->Current->SessionConfigData.IsId); 822 IScsiConvertIsIdToString (IfrNvData->IsId, Private->Current->SessionConfigData.IsId); 823 824 break; 825 826 case KEY_SAVE_CHANGES: 827 // 828 // First, update those fields which don't have INTERACTIVE set. 829 // 830 Private->Current->SessionConfigData.Enabled = IfrNvData->Enabled; 831 Private->Current->SessionConfigData.InitiatorInfoFromDhcp = IfrNvData->InitiatorInfoFromDhcp; 832 Private->Current->SessionConfigData.TargetPort = IfrNvData->TargetPort; 833 if (Private->Current->SessionConfigData.TargetPort == 0) { 834 Private->Current->SessionConfigData.TargetPort = ISCSI_WELL_KNOWN_PORT; 835 } 836 837 Private->Current->SessionConfigData.TargetInfoFromDhcp = IfrNvData->TargetInfoFromDhcp; 838 Private->Current->AuthConfigData.CHAPType = IfrNvData->CHAPType; 839 840 // 841 // Only do full parameter validation if iSCSI is enabled on this device. 842 // 843 if (Private->Current->SessionConfigData.Enabled) { 844 // 845 // Validate the address configuration of the Initiator if DHCP isn't 846 // deployed. 847 // 848 if (!Private->Current->SessionConfigData.InitiatorInfoFromDhcp) { 849 CopyMem (&HostIp.v4, &Private->Current->SessionConfigData.LocalIp, sizeof (HostIp.v4)); 850 CopyMem (&SubnetMask.v4, &Private->Current->SessionConfigData.SubnetMask, sizeof (SubnetMask.v4)); 851 CopyMem (&Gateway.v4, &Private->Current->SessionConfigData.Gateway, sizeof (Gateway.v4)); 852 853 if ((Gateway.Addr[0] != 0)) { 854 if (SubnetMask.Addr[0] == 0) { 855 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, L"Gateway address is set but subnet mask is zero.", NULL); 856 Status = EFI_INVALID_PARAMETER; 857 break; 858 } else if (!IP4_NET_EQUAL (HostIp.Addr[0], Gateway.Addr[0], SubnetMask.Addr[0])) { 859 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, L"Local IP and Gateway are not in the same subnet.", NULL); 860 Status = EFI_INVALID_PARAMETER; 861 break; 862 } 863 } 864 } 865 // 866 // Validate target configuration if DHCP isn't deployed. 867 // 868 if (!Private->Current->SessionConfigData.TargetInfoFromDhcp) { 869 CopyMem (&HostIp.v4, &Private->Current->SessionConfigData.TargetIp, sizeof (HostIp.v4)); 870 if (!NetIp4IsUnicast (NTOHL (HostIp.Addr[0]), 0)) { 871 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, L"Target IP is invalid!", NULL); 872 Status = EFI_INVALID_PARAMETER; 873 break; 874 } 875 876 // 877 // Validate iSCSI target name configuration again: 878 // The format of iSCSI target name is already verified when user input the name; 879 // here we only check the case user does not input the name. 880 // 881 if (Private->Current->SessionConfigData.TargetName[0] == '\0') { 882 CreatePopUp ( 883 EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, 884 &Key, 885 L"iSCSI target name is NULL!", 886 NULL 887 ); 888 Status = EFI_INVALID_PARAMETER; 889 break; 890 } 891 892 } 893 894 if (IfrNvData->CHAPType != ISCSI_CHAP_NONE) { 895 if ((IfrNvData->CHAPName[0] == '\0') || (IfrNvData->CHAPSecret[0] == '\0')) { 896 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, L"CHAP Name or CHAP Secret is invalid!", NULL); 897 Status = EFI_INVALID_PARAMETER; 898 break; 899 } 900 901 if ((IfrNvData->CHAPType == ISCSI_CHAP_MUTUAL) && 902 ((IfrNvData->ReverseCHAPName[0] == '\0') || (IfrNvData->ReverseCHAPSecret[0] == '\0')) 903 ) { 904 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, L"Reverse CHAP Name or Reverse CHAP Secret is invalid!", NULL); 905 Status = EFI_INVALID_PARAMETER; 906 break; 907 } 908 } 909 } 910 911 BufferSize = sizeof (Private->Current->SessionConfigData); 912 gRT->SetVariable ( 913 Private->Current->MacString, 914 &gEfiIScsiInitiatorNameProtocolGuid, 915 ISCSI_CONFIG_VAR_ATTR, 916 BufferSize, 917 &Private->Current->SessionConfigData 918 ); 919 920 BufferSize = sizeof (Private->Current->AuthConfigData); 921 gRT->SetVariable ( 922 Private->Current->MacString, 923 &gIScsiCHAPAuthInfoGuid, 924 ISCSI_CONFIG_VAR_ATTR, 925 BufferSize, 926 &Private->Current->AuthConfigData 927 ); 928 *ActionRequest = EFI_BROWSER_ACTION_REQUEST_FORM_APPLY; 929 break; 930 931 default: 932 break; 933 } 934 } 935 936 if (!EFI_ERROR (Status)) { 937 // 938 // Pass changed uncommitted data back to Form Browser 939 // 940 HiiSetBrowserData (&gIp4IScsiConfigGuid, mVendorStorageName, sizeof (ISCSI_CONFIG_IFR_NVDATA), (UINT8 *) IfrNvData, NULL); 941 } 942 943 FreePool (IfrNvData); 944 945 return Status; 946 } 947 948 /** 949 Updates the iSCSI configuration form to add/delete an entry for the iSCSI 950 device specified by the Controller. 951 952 @param[in] DriverBindingHandle The driverbinding handle. 953 @param[in] Controller The controller handle of the iSCSI device. 954 @param[in] AddForm Whether to add or delete a form entry. 955 956 @retval EFI_SUCCESS The iSCSI configuration form is updated. 957 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory. 958 @retval Others Other errors as indicated. 959 **/ 960 EFI_STATUS 961 IScsiConfigUpdateForm ( 962 IN EFI_HANDLE DriverBindingHandle, 963 IN EFI_HANDLE Controller, 964 IN BOOLEAN AddForm 965 ) 966 { 967 LIST_ENTRY *Entry; 968 ISCSI_CONFIG_FORM_ENTRY *ConfigFormEntry; 969 BOOLEAN EntryExisted; 970 EFI_STATUS Status; 971 EFI_MAC_ADDRESS MacAddress; 972 UINTN HwAddressSize; 973 UINT16 VlanId; 974 CHAR16 PortString[128]; 975 UINT16 FormIndex; 976 UINTN BufferSize; 977 VOID *StartOpCodeHandle; 978 VOID *EndOpCodeHandle; 979 EFI_IFR_GUID_LABEL *StartLabel; 980 EFI_IFR_GUID_LABEL *EndLabel; 981 982 ConfigFormEntry = NULL; 983 EntryExisted = FALSE; 984 985 NET_LIST_FOR_EACH (Entry, &mIScsiConfigFormList) { 986 ConfigFormEntry = NET_LIST_USER_STRUCT (Entry, ISCSI_CONFIG_FORM_ENTRY, Link); 987 988 if (ConfigFormEntry->Controller == Controller) { 989 EntryExisted = TRUE; 990 break; 991 } 992 } 993 994 if (AddForm) { 995 if (EntryExisted) { 996 return EFI_SUCCESS; 997 } else { 998 // 999 // Add a new form. 1000 // 1001 ConfigFormEntry = (ISCSI_CONFIG_FORM_ENTRY *) AllocateZeroPool (sizeof (ISCSI_CONFIG_FORM_ENTRY)); 1002 if (ConfigFormEntry == NULL) { 1003 return EFI_OUT_OF_RESOURCES; 1004 } 1005 1006 InitializeListHead (&ConfigFormEntry->Link); 1007 ConfigFormEntry->Controller = Controller; 1008 1009 // 1010 // Get the MAC address and convert it into the formatted string. 1011 // 1012 Status = NetLibGetMacAddress (Controller, &MacAddress, &HwAddressSize); 1013 ASSERT (Status == EFI_SUCCESS); 1014 VlanId = NetLibGetVlanId (Controller); 1015 1016 IScsiMacAddrToStr (&MacAddress, (UINT32) HwAddressSize, VlanId, ConfigFormEntry->MacString); 1017 1018 // 1019 // Get the normal session configuration data. 1020 // 1021 BufferSize = sizeof (ConfigFormEntry->SessionConfigData); 1022 Status = gRT->GetVariable ( 1023 ConfigFormEntry->MacString, 1024 &gEfiIScsiInitiatorNameProtocolGuid, 1025 NULL, 1026 &BufferSize, 1027 &ConfigFormEntry->SessionConfigData 1028 ); 1029 if (EFI_ERROR (Status)) { 1030 ZeroMem (&ConfigFormEntry->SessionConfigData, sizeof (ConfigFormEntry->SessionConfigData)); 1031 1032 // 1033 // Generate OUI-format ISID based on MAC address. 1034 // 1035 CopyMem (ConfigFormEntry->SessionConfigData.IsId, &MacAddress, 6); 1036 ConfigFormEntry->SessionConfigData.IsId[0] = 1037 (UINT8) (ConfigFormEntry->SessionConfigData.IsId[0] & 0x3F); 1038 } 1039 // 1040 // Get the CHAP authentication configuration data. 1041 // 1042 BufferSize = sizeof (ConfigFormEntry->AuthConfigData); 1043 Status = gRT->GetVariable ( 1044 ConfigFormEntry->MacString, 1045 &gIScsiCHAPAuthInfoGuid, 1046 NULL, 1047 &BufferSize, 1048 &ConfigFormEntry->AuthConfigData 1049 ); 1050 if (EFI_ERROR (Status)) { 1051 ZeroMem (&ConfigFormEntry->AuthConfigData, sizeof (ConfigFormEntry->AuthConfigData)); 1052 } 1053 // 1054 // Compose the Port string and create a new EFI_STRING_ID. 1055 // 1056 UnicodeSPrint (PortString, sizeof (PortString), L"Port %s", ConfigFormEntry->MacString); 1057 ConfigFormEntry->PortTitleToken = HiiSetString (mCallbackInfo->RegisteredHandle, 0, PortString, NULL); 1058 1059 // 1060 // Compose the help string of this port and create a new EFI_STRING_ID. 1061 // 1062 UnicodeSPrint (PortString, sizeof (PortString), L"Set the iSCSI parameters on port %s", ConfigFormEntry->MacString); 1063 ConfigFormEntry->PortTitleHelpToken = HiiSetString (mCallbackInfo->RegisteredHandle, 0, PortString, NULL); 1064 1065 InsertTailList (&mIScsiConfigFormList, &ConfigFormEntry->Link); 1066 mNumberOfIScsiDevices++; 1067 } 1068 } else { 1069 ASSERT (EntryExisted); 1070 1071 mNumberOfIScsiDevices--; 1072 RemoveEntryList (&ConfigFormEntry->Link); 1073 FreePool (ConfigFormEntry); 1074 } 1075 // 1076 // Allocate space for creation of Buffer 1077 // 1078 1079 // 1080 // Init OpCode Handle 1081 // 1082 StartOpCodeHandle = HiiAllocateOpCodeHandle (); 1083 ASSERT (StartOpCodeHandle != NULL); 1084 1085 EndOpCodeHandle = HiiAllocateOpCodeHandle (); 1086 ASSERT (EndOpCodeHandle != NULL); 1087 1088 // 1089 // Create Hii Extend Label OpCode as the start opcode 1090 // 1091 StartLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (StartOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL)); 1092 StartLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL; 1093 StartLabel->Number = DEVICE_ENTRY_LABEL; 1094 1095 // 1096 // Create Hii Extend Label OpCode as the end opcode 1097 // 1098 EndLabel = (EFI_IFR_GUID_LABEL *) HiiCreateGuidOpCode (EndOpCodeHandle, &gEfiIfrTianoGuid, NULL, sizeof (EFI_IFR_GUID_LABEL)); 1099 EndLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL; 1100 EndLabel->Number = LABEL_END; 1101 1102 FormIndex = 0; 1103 NET_LIST_FOR_EACH (Entry, &mIScsiConfigFormList) { 1104 ConfigFormEntry = NET_LIST_USER_STRUCT (Entry, ISCSI_CONFIG_FORM_ENTRY, Link); 1105 1106 HiiCreateGotoOpCode ( 1107 StartOpCodeHandle, // Container for dynamic created opcodes 1108 FORMID_DEVICE_FORM, // Target Form ID 1109 ConfigFormEntry->PortTitleToken, // Prompt text 1110 ConfigFormEntry->PortTitleHelpToken, // Help text 1111 EFI_IFR_FLAG_CALLBACK, // Question flag 1112 (UINT16)(KEY_DEVICE_ENTRY_BASE + FormIndex) // Question ID 1113 ); 1114 1115 FormIndex++; 1116 } 1117 1118 HiiUpdateForm ( 1119 mCallbackInfo->RegisteredHandle, 1120 &gIp4IScsiConfigGuid, 1121 FORMID_MAIN_FORM, 1122 StartOpCodeHandle, // Label DEVICE_ENTRY_LABEL 1123 EndOpCodeHandle // LABEL_END 1124 ); 1125 1126 HiiFreeOpCodeHandle (StartOpCodeHandle); 1127 HiiFreeOpCodeHandle (EndOpCodeHandle); 1128 1129 return EFI_SUCCESS; 1130 } 1131 1132 /** 1133 Initialize the iSCSI configuration form. 1134 1135 @param[in] DriverBindingHandle The iSCSI driverbinding handle. 1136 1137 @retval EFI_SUCCESS The iSCSI configuration form is initialized. 1138 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory. 1139 @retval Others Other errors as indicated. 1140 **/ 1141 EFI_STATUS 1142 IScsiConfigFormInit ( 1143 VOID 1144 ) 1145 { 1146 EFI_STATUS Status; 1147 EFI_HII_DATABASE_PROTOCOL *HiiDatabase; 1148 ISCSI_FORM_CALLBACK_INFO *CallbackInfo; 1149 1150 Status = gBS->LocateProtocol (&gEfiHiiDatabaseProtocolGuid, NULL, (VOID **)&HiiDatabase); 1151 if (EFI_ERROR (Status)) { 1152 return Status; 1153 } 1154 1155 CallbackInfo = (ISCSI_FORM_CALLBACK_INFO *) AllocateZeroPool (sizeof (ISCSI_FORM_CALLBACK_INFO)); 1156 if (CallbackInfo == NULL) { 1157 return EFI_OUT_OF_RESOURCES; 1158 } 1159 1160 CallbackInfo->Signature = ISCSI_FORM_CALLBACK_INFO_SIGNATURE; 1161 CallbackInfo->HiiDatabase = HiiDatabase; 1162 CallbackInfo->Current = NULL; 1163 1164 CallbackInfo->ConfigAccess.ExtractConfig = IScsiFormExtractConfig; 1165 CallbackInfo->ConfigAccess.RouteConfig = IScsiFormRouteConfig; 1166 CallbackInfo->ConfigAccess.Callback = IScsiFormCallback; 1167 1168 Status = gBS->LocateProtocol (&gEfiHiiConfigRoutingProtocolGuid, NULL, (VOID **)&CallbackInfo->ConfigRouting); 1169 if (EFI_ERROR (Status)) { 1170 FreePool(CallbackInfo); 1171 return Status; 1172 } 1173 1174 // 1175 // Install Device Path Protocol and Config Access protocol to driver handle 1176 // 1177 Status = gBS->InstallMultipleProtocolInterfaces ( 1178 &CallbackInfo->DriverHandle, 1179 &gEfiDevicePathProtocolGuid, 1180 &mIScsiHiiVendorDevicePath, 1181 &gEfiHiiConfigAccessProtocolGuid, 1182 &CallbackInfo->ConfigAccess, 1183 NULL 1184 ); 1185 ASSERT_EFI_ERROR (Status); 1186 1187 // 1188 // Publish our HII data 1189 // 1190 CallbackInfo->RegisteredHandle = HiiAddPackages ( 1191 &gIp4IScsiConfigGuid, 1192 CallbackInfo->DriverHandle, 1193 IScsi4DxeStrings, 1194 IScsiConfigDxeBin, 1195 NULL 1196 ); 1197 if (CallbackInfo->RegisteredHandle == NULL) { 1198 FreePool(CallbackInfo); 1199 return EFI_OUT_OF_RESOURCES; 1200 } 1201 1202 mCallbackInfo = CallbackInfo; 1203 1204 return Status; 1205 } 1206 1207 /** 1208 Unload the iSCSI configuration form, this includes: delete all the iSCSI 1209 device configuration entries, uninstall the form callback protocol and 1210 free the resources used. 1211 1212 @param[in] DriverBindingHandle The iSCSI driverbinding handle. 1213 1214 @retval EFI_SUCCESS The iSCSI configuration form is unloaded. 1215 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory. 1216 **/ 1217 EFI_STATUS 1218 IScsiConfigFormUnload ( 1219 IN EFI_HANDLE DriverBindingHandle 1220 ) 1221 { 1222 ISCSI_CONFIG_FORM_ENTRY *ConfigFormEntry; 1223 1224 while (!IsListEmpty (&mIScsiConfigFormList)) { 1225 // 1226 // Uninstall the device forms as the iSCSI driver instance may fail to 1227 // control the controller but still install the device configuration form. 1228 // In such case, upon driver unloading, the driver instance's driverbinding. 1229 // stop () won't be called, so we have to take this chance here to uninstall 1230 // the device form. 1231 // 1232 ConfigFormEntry = NET_LIST_USER_STRUCT (mIScsiConfigFormList.ForwardLink, ISCSI_CONFIG_FORM_ENTRY, Link); 1233 IScsiConfigUpdateForm (DriverBindingHandle, ConfigFormEntry->Controller, FALSE); 1234 } 1235 1236 // 1237 // Remove HII package list 1238 // 1239 mCallbackInfo->HiiDatabase->RemovePackageList ( 1240 mCallbackInfo->HiiDatabase, 1241 mCallbackInfo->RegisteredHandle 1242 ); 1243 1244 // 1245 // Uninstall EFI_HII_CONFIG_ACCESS_PROTOCOL 1246 // 1247 gBS->UninstallMultipleProtocolInterfaces ( 1248 mCallbackInfo->DriverHandle, 1249 &gEfiDevicePathProtocolGuid, 1250 &mIScsiHiiVendorDevicePath, 1251 &gEfiHiiConfigAccessProtocolGuid, 1252 &mCallbackInfo->ConfigAccess, 1253 NULL 1254 ); 1255 FreePool (mCallbackInfo); 1256 1257 return EFI_SUCCESS; 1258 } 1259
